面向对象-继承的学习

面向对象的三大特征：封装，继承，多态

• 继承是多态的前提，没有继承，就没有多态
• 继承主要解决的问题就是：共性抽取
• 父类：也叫基类，超类
• 子类：派生类

继承关系的特点：

• 1.子类可以拥有父类的内容
• 2.子类还可以拥有自己的专有内容

java语言不支持多继承，是单继承语言，支持多级继承，父类可以有很多子类，但子类只能有一个父类

子父类中成员变量的访问：
子父类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量：

•   等号左边是谁，就优先用谁，没有则向上找
  

间接通过成员方法访问成员变量：

•   该方法属于谁，就优先用谁，没有则向上找
  

区分子类方法中重名的三种：

• 局部变量： 直接写变量名
• 本类的成员变量： this.变量名
• 父类的成员变量： super.变量名

//父类
public class Fu {
    int num = 100;                        
}

//子类继承父类
public class Zi extends Fu {	
    //子类成员变量
    int num = 200;
    public void methodZi(){
    	//局部变量
        int num = 300;
        System.out.println(num);//300
        System.out.println(this.num);//200
        System.out.println(super.num);//100
    }

在子父类继承关系中，创建子类对象，访问成员方法的规则：

•   创建的对象是谁，就优先用谁，如果没有则向上找
  

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，不会向下

重写(Override)：覆盖，重写

• 在继承关系中，方法的名称一样，参数列表也一样
• 特点：创建子类对象，则优先用子类方法

//父类
public class Fu {	
	//父类成员方法
	public void method(){
        	System.out.println("fu");
   	 }
}

//子类继承父类
public class Zi extends Fu {
    		
    //覆写父类中的方法
	public void method(){
        	System.out.println("zi");
    	}
}

方法覆盖重写的注意事项：

• 1.必须保证子父类之间方法的名称相同，参数列表也相同
  @Overriae：写在方法前面，用来检测是不是有效的正确覆盖重写
  这个注解就算不写，只要满足要求，也是正确的方法覆盖重写

• 2.子类方法的返回值必须小于等于父类方法的返回值范围
  扩展：java.lang.Object类是所有类的公共最高类。java.lang.String就是Object的子类

• 3.子类方法的权限必须大于等于父类方法的权限修饰符
  扩展： public > protected > (default) > private
  备注： (default)不是关键字default，而是什么都不写，留空

设计原则：

• 对于已经投入使用的类，尽量不要进行修改，推荐定义一个新的类，
  来重复利用其中共性内容，并且添加改动新内容，《继承》

继承关系中，父子类构造方法的访问特点：

1.子类构造方法当中有一个默认隐含的 “super()”调用，所有一定是先调用的父类构造方法，后执行子类构造方法

2.子类构造可以通过super关键字来调用父类重载构造

3.super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super

总结：
子类必须调用父类构造方法，且只有子类构造方法才能调用父类构造方法
不写则默认赠送一个super，写了则用写的指定的super调用，super只能有一个且必须是子类构造的第一个

super关键字的三种用法：
1.在子类的成员方法中，访问父类的成员变量
2.在子类的成员方法中，访问父类的成员方法
3.在子类的构造方法中，访问父类的构造方法

//父类
public class Fu {
    int num = 10;
    Fu(){//父类无参构造
        System.out.println("父类无参构造方法");
    }
    Fu(int num){//父类全参构造
        System.out.println("父类有参构造方法"+num);
    }
    
    public void method(){
 	System.out.printnln("父类方法");
    }
}

//子类
public class Zi extends Fu {
    int num = 20;
    Zi(){//子类无参构造
        super(50);//调用父类有参构造
        System.out.println("子类无参构造方法");
    }
    Zi(int num){//子类全参构造
        super();//调用了父类无参构造
        System.out.println("子类有参构造方法");
    }   
    public void method(){
    	super.method();//调用父类方法
    	System.out.println(super.num); //调用父类成员变量
    }
}
    

super关键字用来访问父类内容，而this关键字用来访问本类内容，用法也有三种

• 1.在本类的成员方法中，访问本类的成员变量

• 2.在本类的成员方法中，访问本类的另一个成员方法

• 3.在本类的构造方法中，访问本类的另一个构造方法
  在第三种用法中要注意：
  this(…)调用也必须是构造方法的第一个语句，唯一一个
  super和this两种构造调用，不能同时使用

public class ZiThis extends Fu {
    int num = 15;

    public ZiThis(){
        //super(); //this和super不能同时使用
        this(1);//本类中的无参构造，调用本类有参构造
    }
    public ZiThis(int c){
        this(1,2);//调用本类其他构造
    }
    public ZiThis(int a,int b){
        super();//调用父类构造
    }

    public void method(){
        int num = 20;
        System.out.println(num);//访问局部变量
        System.out.println(this.num);//访问本类的成员变量
        System.out.println(super.num);//访问父类的成员变量
    }

    public void show1(){
        this.show2();//访问本类的另一个成员方法
        System.out.println("111");
    }
    public void show2(){
        System.out.println("222");
    }

}