Java面向对象超详细讲解（3）零基础入门也能学懂

目录

可变个数的形参

方法参数的值传递机制（重点）

针对基本数据类型

继承

方法的重写（override/overwrite）

对象数组

---

可变个数的形参

可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。

可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。二者不可共存。

可变个数形参在方法中的形参中，必须声明在末尾。

可变个数形参在方法中的形参中，最多只能声明一个可变形参。

public class MethodArgs{
public statuc void main(String[] args){
MethodArgs test = new MethodArgs();
test.show(12);
test.show(new String[]{"AA","BB","CC"});
}
public void show(int i){
​
}
    
public void show(String... strs){//和字符串数组相同
for(int i = 0;i<strs.length;i++){
System.out.println(strs[i]);
}
}
    //此方法与上一方法不可共存
    //public void show(String[] strs){
    //
    //}
    
public void show(int i,String... strs){
    
}
}

方法参数的值传递机制（重点）

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。

如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

public class ValueTransferTest{
public sattic void main(String[] args){
 //基本数据类型
 int m = 10;
 int n = m;
 System.out.println("m="+m+","+"n="+n);
 
 n=20;
 System.out.println("m和n:"+m+" "+n);
 
 //引用数据类型
 Order o1 = new Order();
 o1.orderId = 1001;
 
 Order o2 = o1;//赋值后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
 System.out.println("o1.orderId和o2.orderId："+o1.orderId+o2.orderId);
 
 o2.orderId = 1002;
    System.out.println(o1.orderId+o2.orderId);
    }
}
class Order{
    int orderId;
}

针对基本数据类型

方法的形参的传递机制：值传递

形参：方法定义时，声明的小括号内的参数

实参：方法定义时，实际传递给形参的数据

值传递机制：

如果参数是基本数据类型，此时实参赋值给形参的是实参真实存储的数据值。

swap方法交换两个数据，在主方法中输出，结果和没交换一样 这是为什么？只能在swap方法中输出才能交换

继承

1.Person类
​
public class Person{
​
    String name;
    private int age;
    
    public Person(){
    
    }
    
    public Person(String name,int age){
    this.name = name;
    this.age = age;
    }
    public void eat(){
    System.out.println("吃饭");
    sleep();
    }
    private void sleep(){
    System.out.println("睡觉");
    }
    public void setAge(int age){
    this.age = age;
    }
    public int getAge(){
    return age;
    }
}

2.Student类
public class Student extends Person{
String major;
​
public Student(){
​
}
public Student(String name,int age,String major){
this.name = name;
setAge(age);
this.major = major;
}
​
public void study(){
System.out.println("学习");
}
public void show(){
System.out.println("name:"+name+",age = "+getAge());
}
​
}

3.测试类
public class ExtendsTest{
​
    public static void main(String[] args){
    Person p1 = new Person();
    p1.age = 1;
    p1.eat();
    System.out.println("*********");
    
    Student s1 = new Student();
    s1.eat();
    s1.sleep();
    s1.name = "Tom";
    
    s1.setAge(10);
    System.out.println(s1.getAge());
    }
}

继承的规则

• 一个类可以被多个类继承

• 类的单继承性：一个类只能有一个父类

• 如果没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类（所有的java类都直接或间接的继承于这个类）

public class ManKind{
    int sex;
    int salary;
    public void manOrWoman(){
    if(sex==1){
    System.out.println("man");
    }
    else if(sex==0){
    Sytstem.out.println("woman");
    }
    
    public void employeed(){
    if(salary==0){
    System.out.println("no job");
    }
    else if(salary=!=0){
    System.out.println("job");
    }
    }
    
    }
}

方法的重写（override/overwrite）

重写：子类继承父类之后，对父类中的方法进行覆盖

重写之后，当创建子类对象后，通过子类对象去调用父类中同名同参数方法时，执行的是子类重写父类的方法

区分重写与重载：

• 方法的重写Overriding和Overloading是java多态性的不同表现。
• 重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的表现。
• 如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding).
• 子类的对象使用这个方法时，将调用子类中的定义，对他而言，父类中的定义如同被屏蔽了。
• 如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同参数类型，则成为方法的重载。

重写的规定：

方法的声明：权限修饰符 返回值类型 方法名（形参列表）{

//方法体

}

子类中的叫重写的方法，父类中的叫被重写的方法

子类重写的方法的方法名和形参列表必须和父类被重写的方法的方法名，形参列表相同

子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限，

特殊情况：子类不能重写父类中声明为private权限的方法

对象数组

对象既可以存储基本类型值，也可以存储对象。

Circle[] circleArray = new Circle[10];

初始化数组circleArray 可以使用for循环：

for(int i = 0;i<circleArray.length;i++){
circleArray[i] = new CIrcle();
}

对象的数组实际上是引用变量的数组

当使用new操作符创建对象数组后，这个数组中的每个元素都是默认值为null的引用变量。