父类与子类继承，super关键字，方法重写与重载（学习笔记）

时间 2019-12-07

原文原文链接

只有秃头才能变强java

继承

多个类中存在相同属性和行为时，将这些相同的属性和内容都单独放在一个类中，那么多个类就无需定义这些属性和方法，直接继承该类
格式：class 子类名 extends 父类名（超类）
-定义一个类后咱们能够在一个已经存在的类的基础上，继承其属性和范围，同时也能够定义新的属性和范围

package Demo1;
//使用继承后，猫和狗都属于动物类，都要吃和叫
//因此创建一个动物类
class Animals{
    public void eat() {
        System.out.println("吃");
    }
    public void barking() {
        System.out.println("叫");
    }
}
//猫和狗都继承动物类
class Cat extends Animals{}
class Dog extends Animals{}

public class ExtendsDemo {
    public static void main(String[] args) {
        //建立一只小狗，并调用eat和barking方法
        Dog dog=new Dog();
        dog.eat();
        dog.barking();
        //建立一只小猫，并调用eat和barking方法
        Cat cat=new Cat();
        cat.eat();
        cat.barking();
    }
}
复制代码

运行结果app

吃
叫
吃
叫ide

使用继承的优势：

提升了代码的复用性：多个类相同的成员能够放到一个类中
提升了代码的维护性：若代码须要修改，则修改一处便可
让类与类之间产生关系，是多态的前提

弊端

类的耦合性很强
设计原则：高内聚低耦合，内聚就是本身完成某件事的能力，耦合是类与类之间的关系。咱们在设计的时候原则是这样的：本身能完成的事情就不麻烦别人，若是未来对方须要修改时，对于咱们的影响比较小。

Java中继承的特色

Java只支持单继承，不支持多继承：一个类只能有一个父类，不能够有多个父类，就比如咱们每一个人只有一个父亲。
Java支持多层继承
class A{}
class B extends A{}
class C extends B{}

//Java只支持单继承，不支持多继承
class Father{}
class Mother{}
//正确的写法
class Son extends Father{}
//错误的写法
class Son extends Father and Mother{}
复制代码

package Demo1;

//Java支持多重继承
class GrandFather {
    public void say() {
        System.out.println("我是你爷爷");
    }
}

class Father extends GrandFather {
    public void show() {
        System.out.println("我是你爸爸");
    }
}

class Son extends Father {
}

public class ExtendsDemo {
    public static void main(String[] args) {
        // 建立一个儿子对象
        Son son = new Son();
        // 调用父亲的方法
        son.show();
        // 调用爷爷的方法
        son.say();
    }
}
复制代码

运行结果：this

我是你爸爸
我是你爷爷spa

注意事项

子类只能继承父类的非私有成员（成员方法和成员变量），体现了继承的另外一个弊端，封装性。
子类不能继承父类的构造方法，能够经过super关键字去访问父类的构造方法。
当知足 is a的关系时能够考虑使用继承，如猫是动物的一种，树是植物的一种
示例

package Demo1;

class Father {
    private int num = 10;
    public int num1 = 20;

    // 私有方法，子类不能继承
    private void show() {
        // num能够在父类中访问
        System.out.println(num);
        System.out.println(num1);
    }

    public void say() {
        System.out.println(num);
        System.out.println(num1);
    }
}

class Son extends Father {
    public void funtion() {
        // 子类不能继承父类的私有成员
        // System.out.println(num);
        System.out.println(num1);
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        // 建立对象
        Son son = new Son();
        // s.show(),子类不能继承父类的私有成员方法
        son.say();
        son.funtion();

    }
}
复制代码

输出结果
10
20
20设计

继承中成员变量的关系，当子类中成员变量与父类中的成员变量名称同样时，在子类方法中访问一个变量的查找顺序：code

在子类方法的局部范围找，有就使用
在子类的成员范围找，有就使用
在父类的成员范围找，有就使用
若是都没有找到，则报错

super关键字

super的用法和this的用法很像，super表明父类引用，能够操做父类的成员。this表明本类对应的引用。
访问成员变量： this.成员变量：调用本类的成员变量，super.成员变量：调用父类的成员变量。
访问构造方法：this(…)调用本类的构造方法，super(…)调用父类的构造方法
访问成员方法：this.成员方法（）调用本类的成员方法，super.成员方法（）调用父类的构造方法

继承中构造方法的关系

子类的全部的构造方法都默认访问父类中空参数的构造方法，子类会继承父类中的数据，因此在子类初始化以前，必定要先完成父类数据的初始化
注意：子类的每个构造方法第一条默认都是：super()。

package Demo1;

class Father {

   public Father() {
       System.out.println("Father的无参构造");    
   }
   public Father(String name) {
       System.out.println("Father的有参构造");
   }

}

class Son extends Father {
    public Son() {
        //super(),子类的每一个构造方法第一条语句默认super()
        System.out.println("son的无参构造");
    }
    public Son(String name) {
        //super()
        System.out.println("son的有参构造");
    }

}

public class ExtendsDemo {
    public static void main(String[] args) {
        // 建立对象
        Son son = new Son();
        System.out.println("***************");
        Son son2=new Son("tom");

    }
}
复制代码

输出结果
Father的无参构造
son的无参构造orm

Father的无参构造
son的有参构造视频

从运行结果能够看出，每次建立一个子类对象都会访问父类的无参构造方法，当父类中没有无参构造方法时，项目会报错，解决方法：对象

在父类中添加一个无参的构造方法
经过使用super关键字显示地调用父类的带参构造方法
子类经过this去调用本类的其余构造方法
子类中必定要有一个访问父类的构造方法，不然父类数据就没有初始化
注意事项：

this(…)或者super(…)必须出如今语句的第一条，若是不放在语句的第一条，那么就有可能对父类数据进行屡次初始化，因此必须放在第一条语句上

package Demo1;

class Father {

    /*
     * public Father() { System.out.println("Father的无参构造"); }
     */
    public Father(String name) {
        System.out.println("Father的有参构造");
    }

}

class Son extends Father {
    public Son() {
        super("John");
        System.out.println("son的无参构造");
        // super("John");
    }

    public Son(String name) {
        // super("Jimmy");
        this();
        System.out.println("son的有参构造");
    }

}

public class ExtendsDemo {
    public static void main(String[] args) {
        // 建立对象
        Son son = new Son();
        System.out.println("***************");
        Son son2 = new Son("tom");

    }
}
复制代码

输出结果
Father的有参构造
son的无参构造

Father的有参构造
son的无参构造
son的有参构造

继承中成员方法的关系

若子类中的成员方法与父类中的成员方法同样，经过子类调用对象的顺序为：先找子类中有没有这个方法，有就使用，没有就在父类中找，有就使用，再没有则报错

方法的重写与重载

方法的重写：子类中出现与父类中如出一辙的方法声明，也被称为方法覆盖，方法重写
方法的重载：本类中出现的方法名同样，参数列表不同的方法，与放回值没有关系
使用特色：若是方法名不同，就调用对应的方法，若是方法名相同，则使用的是子类的方法
方法重写的应用：当子类须要父类的功能时，而该父类的功能主体中又有子类本身的内容，此时子类既能够重写父类的方法，又定义了子类特有的内容。
注意事项：
- 父类中的私有方法不能被重写，由于父类中的私有方法子类根本没法继承
- 子类重写父类方法时，访问权限不能更低，最好一致，假设一个父类A拥有的方法为public void set(){},能够被其余任意对象调用，这个方法被子类B覆盖后写为protected void set(){}即默认为protected的访问权限，只能被本包及其子类所访问，假设其余包中的对象C调用方法为get(A a){a.set()},而此时传入的对象为B类对象，假设B此时转型为A，可是B此时set()调用权限已经缩小了将形成错误，因此子类对象的访问修饰要比父类的访问修饰要大。

package Demo1;

class Laptop extends Pc{
    public void Read(String name) {
        super.Read(name);
        System.out.println("我能够看视频");
    }  
}
class Pc{
    public void Read(String name) {
        System.out.println("我能够看小说");
    }
}
public class ExtendsDemo1 {
    public static void main(String[] args) {
        //建立对象
        Laptop lt=new Laptop();
        lt.Read("哈利波特");
    }

}
复制代码

输出结果：
我能够看小说
我能够看视频

方法重写（override）与重载的区别（overload）

方法重写：在子类中，出现和父类如出一辙的方法声明
方法重载：在同一个类中，出现的方法名相同，参数列表不一样的现象
方法重载能够改变返回值类型，重写则不行

浑浑噩噩一天又过去了