面向对象
参数
参数分为形参(方法声明时的参数)与实参（方法调用时实际传给形参的参数值）
将对象作为参数传递给方法
（1）定义一个Circle类,包含一个double型是r属性代表圆的半径，一个findArea()方法返回圆的面积。
class Circle{
double r;
public double findArea(){
return r * 3.14 * 3.14;
}
}
（2）定义一个类PassObject，在类中定义一个方法printArea()，定义如下：
public void printArea(Circle c,int time )
在printArea方法中打印1到time之间的半径（整数）及对应的圆面积。
在main方法中调用printArea()方法，调用完毕后输入当前半径值。
class Circle{
double radius;
public double findArea(){
return radius * Math.PI * Math.PI;
}
public void setRadius(double r){
radius = r;
}
public double getRadius(){
return radius;
}
}
class PassObject{
public void printArea(Circle c,int time){
System.out.println("开始啦！");
for(int i = 1;i <= time;i++ ){
c.setRadius(i);
System.out.println(c.getRadius() + "\t" + c.findArea());
}
}
public static void main(String[] args){
//对象实例化
PassObject p = new PassObject();
Circle c = new Circle();
//调用方法
p.printArea(c,5);
System.out.println("当前半径为：" + c.radius);
}
}
参数传递
- Java里方法的参数传递只有一种：值传递（将实际参数值的副本传入方法内，参数本身不受影响）
- 形参是基本数据类型，值传递时，实参会将其值传递给形参的基本数据类型的变量
- 形参是引用数据类型，值传递时，实参会将其内存地址传递给形参的引用数据类型的变量
public class Test2 {
public static void main(String[] args) {
Test2 t = new Test2();
t.first();
}
public void first(){
int i = 5;
Value v = new Value();
v.i = 25;
second(v,i);
System.out.println(v.i);//20
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.println(v.i + " " + i);//50 0
}
}
class Value{
int i = 50;
}
可变个数的形参
- 可变个数的形参的方法和同名的方法之间构成重载
- 可变个数的形参在调用时，个数从0开始，到无穷多个都行
- 使用可变个数的形参的方法与使用数组的形参的方法是一致的（相同类型的数组的形参与可变个数的形参会·被认为是相同）
- 可变个数的形参一定要放在不可变参数的后面（即
int i,String ... args） - 在一个方法中，只能有一个可变个数的形参
例
public class Test1 {
public static void main(String[] args) {
Test1 t = new Test1();
t.hello();
t.hello(new String[]{"hello China","hello math","hello English"});//优先调用的可变个数的形参
t.hello("hello 1","hello 2","hello 3"); //调用的可变个数的形参
t.hello(1,"hello 2","hello 3");
}
//以下方法构成重载
public void hello(){
System.out.println("hello,world!");
}
//可变个数的形参
public void hello(String ... args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i] + "!");
}
}
public void hello(int i,String ... args){
System.out.println(i);
for(int j = 0;i < args.length;j++){
System.out.println(args[j] + "???");
}
}
public void hello(int[] args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i]);
}
}
}
匿名类对象
- 创建的类的对象是匿名的
- 当只需要调用一次类的对象时，就可以考虑使用匿名的方式创建类的对象
- 匿名类对象只能使用一次。
正常情况
PassObject p = new PassObject();
Circle c = new Circle();
//调用方法
p.printArea(c,5);
使用匿名类对象
p.printArea(new Circle(),5)
构造器（构造方法 constructor）
作用
-
创建对象
-
给创建的对象的属性赋值
设计类时
- 若不显示声明类的构造器，程序会默认提供一个空参的构造器（构造器名需与所在的类名一致）
- 一旦显示声明类的构造器，程序默认的构造器就不会再提供
- 声明类的构造器的格式：
权限修饰符 类名(形参){} - 类的多个构造器可以构成重载
- 类对象的属性赋值的先后顺序：
属性默认初始化 > 属性的显性初始化 >通过构造器给属性初始化 > 通过"对象.方法"的方式给属性赋值
public class Test3 {
public static void main(String[] args) {
//Person p = new Person(); //Person()即为空参的构造器
Person p = new Person("春花", 22);
System.out.println(p.getName());
}
}
class Person{
private String name;
private int age;
//构造器
public Person(String n){
name = n;
age = a;
}
public Person(String n,int a){
name = n;
age = a;
}
public String getName(){
return name;
}
public String getAge(){
return age;
}
}
练习
题一
题二
2.面向对象的三大特征：封装，继承，多态
封装与隐藏
将类的属性似有化，提供公共的方法（setter & getter）来实现调用
- 当创建类的对象后，如果直接通过"对象.属性"的方式来赋值，可能会出现不满足实际的意外；而通过"
对象.方法"的方式来控制对象对属性的访问,就能满足实际需求。 - private 修饰的属性,只能在本类中被调用，出了此类，就不能被调用。
public class Test3 {
public static void main(String[] args) {
zoo z = new zoo();
z.setAge(4);
z.setName("二狗");
z.info();
//编译不通过（属性被私有化）
z.name = "春花";
}
}
class zoo{
//属性私有化(不能直接被调用属性)
private String name;
private int age;
public void info(){
System.out.println("name: " + name + " age: " + age);
}
public void setAge(int i){
if(i > 0 && i < 200){
age = i;
}else{
System.out.println("输入错误");
}
}
public void setName(String i){
name = i;
}
public String getName(){
return name;
}
public String getAge(){
return age;
}
}
访问权限修饰符（4种）
权限从大到小：public protected 缺省 private
练习
题一
题二
感谢大家的支持，关注，评论，点赞！
参考资料：
尚硅谷宋红康20天搞定Java基础上部
87
