新手小白学JAVA 继承 super

港控/mmm° 2021-09-07 16:40 442阅读 0赞

(⊙o⊙)…\# 1 继承

## 1.1概念 ##

继承是面向对象最显著的一个特征  
继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并扩展新的能力.  
Java继承是会用已存在的类的定义作为基础建立新类的技术  
新类的定义可以增加新的数据或者新的功能,也可以使用父类的功能,但不能选择性的继承父类(超类/基类)  
这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用.

## 1.2 特点 ##

1.  使用extends关键字来表示继承关系
2.  相当于子类把父类的功能复制了一份
3.  Java只支持单继承
4.  继承可以传递(爷爷/儿子/孙子这样的关系)
5.  父类的私有成员也会被继承，但由于是私有的不可见，所以子类不能使用父类的私有资源
6.  继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展
7.  像是is a的关系

## 1.3 练习：继承入门案例 ##

创建包: cn.tedu.oopextends  
创建类: ExtendsDemo.java

package cn.tedu.oopextends;
    /*本类用作继承的入门案例*/
    public class ExtendsDemo { 
        public static void main(String[] args) { 
            //5.创建3个类的对象
            Animal a = new Animal();
            Cat c = new Cat();
            MiaoMiao m = new MiaoMiao();
            //6.利用对象调用方法进行测试
            a.eat();
            c.eat();//爸爸类可以使用爷爷类的方法
            m.eat();//孙子类可以使用爷爷类的方法
            /*3.继承还具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子*/
        }
    }
    
    /*1.我们通过extends关键字建立子类与父类的继承关系，格式：子类 extends 父类*/
    /*2.java只支持单继承，一个子类只能有一个父类，但是一个父类可以有多个子类*/
    //1.创建爷爷类
    class Animal{ 
        //4.添加爷爷类的方法
        public void eat(){ 
            //sout是生成打印语句的快捷方式
            System.out.println("小动物Animal吃啥都行~");
        }
    }
    //2.创建爸爸类，并与Animal类建立继承关系
    /*6.继承是is a的关系，比如小猫是小动物，MiaoMiao是一只小猫 * 继承要求子类必须是父类的一种下属类型，依赖性非常强，强耦合*/
    class Cat extends Animal{ 
        //7.定义爸爸类中的属性--成员变量
        int a = 10;//普通属性
        private int b = 100;//私有属性
    }
    //3.创建孙子类,并与Cat类建立继承关系
    class MiaoMiao extends Cat{ 
        /*4.子类可以拥有自己独有的方法，实现了功能的拓展，青出于蓝而胜于蓝*/
        //8.定义孙子类独有的方法
        public void studyJava(){ 
            System.out.println("正在学Java");
            /*5.子类继承了父类以后，可以使用父类的所有非私有资源 * 注意：这个私有资源是由于子类不可见而不能使用的，不是因为没有继承 * 因为子类在继承了父类以后，相当于把父类的功能完全复制了一份*/
            System.out.println(a);//可以使用父类的非私有资源
            //System.out.println(b);//不可以使用父类的私有资源，会报错
        }
    }

# 2 super #

可以通过这个关键字使用父类的内容,Super代表的是父类的一个引用对象  
注意:在构造方法里,出现的调用位置必须是第一行

# 3 方法重写Override #

1.  继承以后,子类就拥有了父类的功能
2.  在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
3.  子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
4.  注意: 父类的私有方法不能被重写
5.  重写的要求:两同两小一大  
    两同:方法名 参数列表 要完全一致  
    两小:  
    子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)  
    子类抛出异常小于等于父类方法抛出异常  
    一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限

# 4 继承的用法 #

## 4.1 练习：super之继承中成员变量使用 ##

创建包: cn.tedu.oopextends  
创建类: TestExtends1.java

package cn.tedu.oopextends;
    /*本类用于测试继承中成员变量的使用*/
    public class TestExtends1 { 
        public static void main(String[] args) { 
            //5.创建对象进行测试
            Son s = new Son();
            s.eat();
        }
    }
    
    //1.创建父类
    class Father{ 
        //6.定义父类的成员变量
        int count = 1;
        int sum = 2;
    
    }
    //2.创建子类
    class Son extends Father{ 
        //4.1定义子类的成员变量
        int sum = 100;
        //3.定义子类中的普通方法
        public void eat(){ 
            //4.2定义子类的局部变量
            int sum = 10;
            System.out.println(sum);//打印子类的局部变量sum
            System.out.println(this.sum);//打印子类的成员变量sum
    
            /*在子类中使用父类的sum资源，需要使用super进行指定 * super表示父类的对象，可以理解成Father super = new Father();*/
           //7.使用父类的成员变量
            System.out.println(count);//使用父类不重名的成员变量
            System.out.println(super.sum);//使用父类重名的成员变量
    
        }
    }

## 4.2 练习：super之继承中构造方法的使用 ##

创建包: cn.tedu.oopextends  
创建类: TestExtends2.java

package cn.tedu.oopextends;
    /*本类用于测试继承中构造方法的使用*/
    /*1.子类创建对象时，默认会先去调用父类的构造方法 * 2.原因是由于子类构造函数的第一行默认存在super()--表示调用父类的无参构造 * 3.当父类没有无参构造时，可以通过super(参数)调用父类的其他含参构造 * 4.构造方法不可以被继承！！因为语法的原因，构造要求与类名同名，所以天然不符合要求*/
    public class TestExtends2 { 
        public static void main(String[] args) { 
            //5.创建对象进行测试
            Father2 f2 = new Father2("红烧肉");
            Son2 s2 = new Son2();
            Son2 s3 = new Son2();
        }
    }
    //1.创建父类
    class Father2{ 
        //3.创建父类的无参构造
    // public Father2(){ 
    // System.out.println("我是Father2的无参构造");
    // }
        public Father2(String str){ 
            System.out.println("爸爸爱吃"+str);
        }
    
    }
    //2.创建子类
    class Son2 extends Father2{ 
        //4.创建子类的无参构造
        public Son2(){ 
            super("红烧狮子头");
            System.out.println("我是Son2类的无参构造");
        }
    }

## 4.3 练习：继承中成员方法的使用 ##

创建包: cn.tedu.oopextends  
创建类: TestExtends3.java

package cn.tedu.oopextends;
    /*本类用于测试继承中方法的使用*/
    /*2.方法的重写：继承后，子类对父类的功能不满意，就可以重写父类的功能 * 重写的语法规则：两同 两小 一大 * 一大：子类方法的修饰符范围 >= 父类方法的修饰符范围--指的是访问控制符 * 两同：方法名相同，参数列表相同 * 两小: 子类方法的返回值类型 <= 父类方法的返回值类型【这个大小是继承关系，不是值的大小】 * 子类方法抛出的异常类型 <= 父类方法抛出的异常类型【这个还没学，不用管】 * 注意：如果父类方法的返回值类型是void,子类保持一致即可 * 注意：子类不可以重写父类的私有方法，还是因为不可见 * */
    public class TestExtends3 { 
        public static void main(String[] args) { 
            //4.创建父子类对象
            Father3 f3 = new Father3();
            Son3 s3 = new Son3();
            f3.eat();
            s3.eat();/*1.继承后，子类可以使用父类的非私有资源*/
            /*3.如果子类对父类的功能进行了重写，调用的是重写以后的功能*/
        }
    }
    
    //1.创建父类
    class Father3{ 
        //3.创建父类的普通方法
        public void eat(){ 
            System.out.println("爸爸爱吃肉");
        }
        public void play(){ 
            System.out.println("爸爸爱放风筝");
        }
    }
    //2.创建子类
    class Son3 extends Father3{ 
        //5.新建子类特有的功能
        public void studyJava(){ 
            System.out.println("我拓展了学java的功能");
        }
        //6.对父类的方法进行重写
        @Override/*4.@Override这是一个注解，可以理解成一个标签，标记这个方法是一个重写的方法*/
        public void eat(){ 
            System.out.println("儿子爱吃蔬菜");
        }
    }

# 5. 拓展 #

## 5.1 this与super的区别 ##

1.  This代表本类对象的引用  
    class Cat\{ this.XXX \} 可以理解成: Cat this = new Cat();
2.  super代表父类对象的引用  
    class Father\{ \}  
    class Son extends Father\{ super.XXX \}  
    可以理解成: Father super = new Father();
3.  this可以在两个变量名相同时,用于区分成员变量和局部变量
4.  this 可以在本类的构造方法之间调用,位置必须是第一条语句,注意,不能相互调用,会死循环
5.  super是建立了继承关系以后,子类如果想用父类的功能,可以通过super调用
6.  如果重写后还想用父类的功能,需要使用super来调用
7.  super在调用父类构造方法时,必须出现在子类构造方法的第一条语句,而且如果父类中没有提供无参构造,子类可以通过super来调用父类其他的含参构造

## 5.2 重载Overload 与重写Override的区别 ##

1.  重载: 是指在一个类中的现象,是指一个类中有很多同名的方法,但是方法的参数列表不同
2.  重写: 是指发生了继承关系以后(两个类),子类去修改父类原有的功能  
    语法规则:子类的方法签名(返回值类型 方法名(参数列表) )与父类一致  
    重写方法的修饰符: 子类权限 >= 父类的权限
3.  重载的意义: 是为了方便外界对方法进行调用,什么样的参数程序都可以找到对应的方法来执行,体现的是程序的灵活性
4.  重写的意义:是在不修改源码的前提下,进行功能的修改和拓展  
    (OCP原则:面向修改关闭,面向拓展开放)