面向对象的三大特征--继承

以你之姓@ 2023-10-07 18:25 3阅读 0赞

>     * 1,继承的认识
>      *      继承是Java种一般到特殊的关系，是一种子类到父类的关系
>      *      被继承的类称为：父类、超类
>      *      继承父类的类称为：子类
>      *
>      *   >继承作用:
>      *      "提高代码的复用"，相同的代码可以定义在父类，子类继承父类，就可以直接使用父类的**         代码
>      *   >继承的特点：
>      *      子类继承一个父类，子类就可以直接得到父类的属性(成员变量)和行为(方法)
>      *   >继承格式
>      *      子类 extends 父类{
>      *
>      *      }
>      *   >继承特点;
>      *          1,单继承：一个类只能继承一个直接父类
>      *              java为什么单继承？
>      *              反证法;如果java是多继承，
>      *              Class A{public void test(){sout()}}
>      *              Class B{public void test(){sout()}}
>      *              Class C extends A,B{main(){new C().test()}}
>      *                 //出现类的二义性，所以不能多继承
>      *          2，多层继承:一个类可以间接继承多个父类(家谱)
>      *          3，一个可以有多个子类
>      *          4，一个类要么继承Object类，要么间接继承Object类，Object时Java中的祖宗类98
>      *
>      *  小结：
>      *      继承是子类得到父类的一种关系
>      *      在Java种继承是"is a"的关系：Cat extends Animal: 猫是一个动物
>      *      在Java中，子类是更加强大，子类不仅继承父类的功能，也可以定义自己的功能
>      *      子类继承一个父类，子类直接可以得到父类的属性和行为,但非所有苏菲属性和行为都可以  **        继承
>      *  2,子类不能继承父类的内容
>      *      >子类不能继承父类的构造器：子类有自己的构造器
>      *
>      *      >子类是否可以继承父类的私有成员（私有成员变量，私有成员方法）(有争议)
>      *          --子类可以继承父类的私有成员，只是不能直接访问
>      *          --可以暴力访问，father飞升了，保险箱继承给你没钥匙，但你可以直接暴力开锁
>      *          
>      *      >类是否可以继承父类的静态成员（有争议）
>      *          --子类不能继承父类的静态成员
>      *          --子类只是可以访问父类的静态成员，父类的静态成员只有一份可以被子类共享
>      *              共享并非继承   共享单车，可以共享不能继承
>      *
>      * 3,继承后-成员变量的访问特点
>      *      就近原则：子类有找子类，子类没有找父类，父类没就报错，子类优先使用自己的属性(成**        员变量)和行为(方法)
>      *  小结：
>      *      this代表了当前对象的引用，可以访问当前子类的成员变量
>      *      super代表父类对象的引用，可以访问父类中的成员变量
>      * 4，继承后-重写@Override
>      *       1，子类重写方法的名称和参数必须与父类被重写的方法一样
>      *       2，子类重写方法的返回值类型申明要么和父类一样，要么比父类返回值范围小
>      *       3，子类重写方法的修饰符权限应该与父类被重写方法的修饰权限相同或者更大
>      *       4，子类重写方法申明破除的异常应该与父类方法申明抛出的异常一样或者范围更小
>      *   静态和私有方法不可用被重写
>      *              父类的静态方法属于父类本身，没有给到子类获取
>      *
>      *  重写规范：
>      *      1，加上@Override，不加被认为新方法，不被认为重写
>      *      2，建议"申明不变，重新实现"//父类怎么申明，子类就怎么申明，
>      *
>      * 5，继承后-super
>      *           super代表父类对象的引用，可以访问父类中的成员变量
>      * 6，继承后-构造器的特点：
>      *      特点：
>      *        >子类的全部构造器默认为一定先访问父类的无参构造器，再执行子类自己的构造器**          (在子类构造器第一行有默认的super()，先有爹后有儿)
>      *          因为子类继承父类，子类就得到了父类的属性和行为
>      *        >当调用子类构造器初始化对象数据时，先调用父类构造器初始化继承父类的属性和行为
>      *        super(..)可以根据参数选择调用父类的某个构造器，以便构造器初始化继承父类的数  *              据
>      *  this与super
>      *      this代表当前对象的引用(继承中指子类对象)
>      *          this.子类成员变量
>      *          this.子类成员方法
>      *          this(。。)可以根据参数匹配访问本类其他构造器//根据参数匹配访问本类其他构造 **               器
>      *      super代表父类对象的引用(继承中指代父类对象空间)
>      *          super.父类成员变量
>      *          super.父类成员方法
>      *          super(..)可以个根据参数匹配访问父类的构造器
>      *      注意：
>      *          this(..)借用本类其他构造器
>      *          super(..)调用父类构造器
>      *          this(..)和super(..)不能同时出现在构造器中

public class DemoExtends {
        public static void main(String[] args) {
            Cat cat = new Cat();
            cat.eat();//调用继承父类()
            cat.run();//子类的（就近/重写）
            cat.play();//父类的，子类没有
            cat.go();//调用父类被重写的方法，go做中转
            cat.Cat();
    //        Cat cat1 = new Cat("狗蛋",3);
    //        Cat cat1 = new Cat("狗蛋");
        }
    }
    
    class Animal{
        String name = "父类名称";
        private int age = 3;
        
        public int getAge() {
            return age;
        }
        
        public void setAge(int age) {
            this.age = age;
        }
        
        public void run(){
            System.out.println("11路跑");
        }
        
        public void play(){
            System.out.println("就是玩");
        }
        
        public Animal(){
            System.out.println("父类Animal无参构造器");
        }
        
        public Animal(String name, int age){
            this.name = name;
            this.age = age;
        }
        
        public Animal(String name){
            
            //this(name,age);//借用兄弟构造器的功能，this(。。)可以根据参数匹配访问本类其他构造器,调用兄弟构造器没有调用父类构造器
        }
    }
    
    class Cat extends Animal{
        String name = "子类名称";
        
        public void eat(){
            String name = "局部名称";
            System.out.println(getAge()+"岁了");//调用继承父类()
            System.out.println(name);//局部名称 就近原则
            System.out.println(this.name);//子类名称
            System.out.println(super.name);//父类名称
        }
        //进行方法重写
        //子类重写方法的名称和形参列表必须与父类被重写方法一样
        @Override
        public void run() {
            System.out.println("开拖拉机跑");
        }
        
        public void go(){//做中转
            run();//子类的
            super.run();//父类的
        }
        
        public void Cat(){
            //super();默认存在，所有会先调用父类的构造器
            System.out.println("子类Cat无参构造器");
        }
        
    //    public Cat(String name,int age){
    //      super(name,age) //根据参数匹配调用父类构造器
    //    }
    
    //    public Cat(String name) {
    //        //super()
    //    }
    }