面向对象03

继承的引用和概述

继承概述

• 多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，那么多个类就无需再定义这些属性和行为，只要继承那个类就好了
• 通过extends关键字可以实现类与类的继承
  class 子类名 extends 父类名{}
• 单独的这个类被称为父类，基类或者超类，这多个类可以称为子类或者派生类
• 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

package miangxiangduixiang03;
//定义一个学生类

public class student {
String name;
int age;
public student(){}
//getXxx（）{}/setXxx(){}
public void eat(){
    System.out.println("吃饭");
}

//定义一个老师类

public class Teacher {
String name;
int age;
public Teacher(){}
//getXxx（）{}/setXxx(){}
public void eat(){
    System.out.println("吃饭");
}

}
/*观察上面俩个代码，我们发现：
 * name,age以及getxxx（）和setxxx（），还有eat（）都是一样的
 * 如果我们后来继续定义类，例：工人类、医生类、军人类他们也具有这样的内容
 * 那么，我们每一次定义这样的类的时候，都要把这些重复的内容在定义一遍
 * 太麻烦了，所以我们需要改进，但是如何改进呢？？？
 * 解：把这些相同的内容定义到一个独立的类中
 * 然后，让这多个类和这个独立的类产生一个关系，有了这个关系后，这多个类就可以具备这独立的类的功能
 * 为了这个功能，java就提供了一个技术   继承
 * 继承怎么表示呢？继承的格式是怎么样的呢？
 * class fu{
 * }
 * class zi extends fu{
 * }
 * 我们就回头改我们的代码
*/
public class person{
    String name;
    int age;
    public person(){}
    //getXxx（）{}/setXxx(){}
    public void eat(){
        System.out.println("吃饭");
    }

}
public class student extends person{
    public student();
}
public class Teacher extends person{
    public void Teacher() {
    }
}
}

继承案例和继承的好处

继承的好处

• 提高了代码的复用性
  （多个类相同的成员可以放到一个类中）
• 提高了代码的维护性
  （如果功能的代码要修改，修改一处即可）
• 让类与类产生了关系，是多态的前提
  （其实这也是继承的一个弊端，他的耦合性很强）

package miangxiangduixiang03;
//使用继承前
public class student2 {

    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public class Teacher2{
        public void eat(){
            System.out.println("吃饭");
        }
        public void sleep(){
            System.out.println("睡觉");
        }
    }
    //使用继承后
    public class person2{
        public void eat(){
            System.out.println("吃饭");
        }
        public void sleep(){
            System.out.println("睡觉");
        }
    }
 class student2 extends person2{}
 class Teacher extends person2{}
}

package miangxiangduixiang03;

import miangxiangduixiang03.student2.Teacher2;

public class student2test {
    public static void main(String[] args) {
        student2 s = new student2();
        s.eat();
        s.sleep();
    
        Teacher2 t = new Teacher2();
        t.eat();
        t.sleep();
    
    }

}
结果都一样
错误，要修改，每个类分开存放

继承的弊端

• 类的耦合性增强
  开发的原则：低耦合，高内聚
  耦合：类与类的关系
  内聚：就是自己完成某件事情的能力

java中类的继承特点

java只继承单继承，不支持多继承

• 一个类只能有一个父类，不可以有多个父类
• class student extends demo{}//ok
• class student extends demo1, demo2//no ok

java 支持多层继承（继承体系）

• class A{}
• class B extends A{}
• class C extends A{}

package miangxiangduixiang03;

public class extendsdemo {
    public void show(){
        System.out.println("我是爷爷");
    }

}


package miangxiangduixiang03;

public class extendsdemoson extends extendsdemo{
    public void method(){
        System.out.println("我是爸爸");
    }

}


package miangxiangduixiang03;

/*public class sonson  extends extendsdemo,extendsdemoson {

}
//这种方是错误的，只能单继承
*/
public class sonson  extends extendsdemoson {

}


package miangxiangduixiang03;

public class extendsdemotest {
    public static void main(String[] args) {
        sonson s = new sonson();
        s.show();
        s.method();
    }

}

继承中构造方法的关系

• 子类中所有的构造方法都会默认访问父类中的空参数的构造方法
  为什么呢？？？
• 因为子类会继承父类中的数据，可能还会使用父类中的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
• 每一个构造方法的第一条语句默认都是：super（）、

package miangxiangduixiang03;

public class father {
    int age;
    public father(){
        System.out.println("这是father的无参构造方法");
    }
    public father(String name){
        System.out.println("这是father的带参构造方法");
    }

}


package miangxiangduixiang03;

public class son1 extends father {
    
    public son1(){
        super();
        System.out.println("这是son的无参构造方法");
    }
    public son1(String name){
        super();
        System.out.println("这是son的带参构造方法");
    }
    
}

package miangxiangduixiang03;

public class fathertest {
    public static void main(String[] args) {
        son1 s = new son1();
        System.out.println("-----------------");
        son1 s2 = new son1("林");
    }
    
}

结果为：
这是father的无参构造方法
这是son的无参构造方法
-----------------
这是father的无参构造方法
这是son的带参构造方法

继承中构造方法的注意事项

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢？
报错
如何解决呢？？？
A 在父类中加一个无参构造方法
B 通过使用super关键字去显示的调用父类的其他构造方法
C 子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问父类的构造方法，否则父类数据就没有初始化
注：this（.......）或者super（......)必须出现在第一条语句上，如果不是放在第一条语句上，
就可能对父亲的数据进行了多次初始化，所以必须放在第一条语句上

package miangxiangduixiang03;

public class father {
    int age;
    /*public father(){
        System.out.println("这是father的无参构造方法");
    }*/
    public father(String name){
        System.out.println("这是father的带参构造方法");
    }

}

package miangxiangduixiang03;

public class son1 extends father {
    
    public son1(){
        super("");
        System.out.println("这是son的无参构造方法");
        /*super("");error,必须放在第一条语句*/
    }
    public son1(String name){
        this();
        System.out.println("这是son的带参构造方法");
    }
    
}

package miangxiangduixiang03;

public class fathertest {
    public static void main(String[] args) {
        son1 s = new son1();
        System.out.println("-----------------");
        son1 s2 = new son1("林");
    }
    
}
结果为：
这是father的带参构造方法
这是son的无参构造方法
-----------------
这是father的带参构造方法
这是son的无参构造方法
这是son的带参构造方法

继承中成员方法关系

案例演示

• 子父类中同名和不同名的成员方法

结论

• 通过子类对象去访问一个方法
  1、首先在子类找
  2、 然后在父类找
  3、 如果还是没有找到就报错（不考虑父亲的父亲.......）

继承中成员方法关系

A 子类中的方法和父类中的方法声明不一样
B 子类中的方法和父类中的方法声明一样
通过子类调用方法：
a 先找子类中，看看有没有这个方法，有就使用
b 再找父类中，看看有没有这个方法，有就使用
c 如果没有就报错

package miangxiangduixiang03;

public class father2 {
    public void show(){
        System.out.println("father show");
    }

}

package miangxiangduixiang03;

public class son2 extends father2{
    public void method(){
        System.out.println("method fangfa");
    }
    public void show(){
        System.out.println("son show");
    }

}

package miangxiangduixiang03;

public class father2test {
     public static void main(String[] args) {
        son2 s = new son2();
        s.show();
        s.method();
        /*s.function();error 找不到符号*/
    }

}
结果为：
son show
method fangfa

方法重写的应用

方法重写概述

• 子类中出现和父类中一模一样的方法声明，也被称为方法覆盖，方法复写
• 使用特点：
  如果方法名不同，就调用对应的方法
  如果方法名相同，最终使用的是子类自己的

方法重写的应用

• 当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法，这样既沿袭了父类的功能，又定义了子类特有的内容

方法重写：

• 子类中出现和父类中方法声明一样的方法

（不同的类中，方法名一样，参数列表一样，返回值一样）

方法重载

• 本类中出现的方法名一样，参数列表不同的方法，与返回值无关

案例

package miangxiangduixiang03;
/*定义一个手机类
通过研究，又发现了一个新手机，可以在打完电话后听天气预报
按照我们基本的设计，我们把代码写了出来
但是呢？我们又发现新手机是手机，所以他应该继承手机类
但是这个设计不是最好的，因为打电话这个功能本来就是手机本身所具备的，所以新手机不提供这个功能，
但是，当我们将new手机类的打电话方法去掉后，他不能打电话了，所以这个不好
最终还是要加上这个功能，由于他继承了手机类，所以我们直接使用父类的功能就行了
那么，怎么使用父类的功能呢？前面讲过的super关键字*/
public class phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }

}


package miangxiangduixiang03;

public class newphone extends phone {
public void call(String name){
    //System.out.println("给"+name+"打电话");
    super.call(name);
    System.out.println("打完电话我还可以听天气预报");
}
}


package miangxiangduixiang03;

public class phonetest {
public static void main(String[] args) {
    newphone np = new newphone();
    np.call("小菜");
}
}

结果为：
给小菜打电话
打完电话我还可以听天气预报

方法重写的注意事项

• 父类中私有方法不能被重写
  （因为父类方法子类就根本无法继承，所以就压根谈不上重写）
• 子类重写父类方法是，访问权限不能更低
  （子类重写的父类方法>=父类的访问权限，不能更低，最好一致）
• 如果父类是静态方法，子类也必须通过静态方法来重写

package miangxiangduixiang03;

public class father3 {
/*private void show(){
    System.out.println("这是私有方法");
}*/
    public void show(){
        System.out.println("这是public方法");
    }
}


package miangxiangduixiang03;

public class son3 extends father3 {
/*public void method(){
    System.out.println("这是共同方法");
}*/
    /*void method(){
        super();error,因为子类访问权限没有父类大
    }*/
    public void method2(){

        System.out.println("这也是public方法");
    }
}


package miangxiangduixiang03;

public class father3test {
/*son3 s = new son3();
s.method();
s.show();error,不能访问父类私有成员方法
*/
    public static void main(String[] args) {
        son3 s= new son3();
        s.method2();
        s.show();
    }
     
     
}
结果为：
这也是public方法
这是public方法