java中的------继承（extends）

day8

1.继承介绍

01.继承让类与类之间产生关系，子父类关系，子类就可以直接使用父类中非私有的成员（变量，方法）

02.实现继承的格式（extends）：

public class 子类类名 extends 父类类名 { }

03.什么时候使用继承？

当多个类之间有共性的内容，抽取而来的共性内容就可以放在父类中。

如：

package day8.text2;

public class TextAnimal {
    public static void main(String[] args) {
        animal sd = new animal();
        sd.setName("小黄");
        sd.setColor("黄色");
        System.out.println(sd.getName());
        System.out.println(sd.getColor());
    }
}

class animal  {
//共性内容：姓名、颜色
    private String name;
    private String color;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
   }
    public void setColor(String color) {
        this.color = color;
    }
}
//子类dog继承父类animal
class dog extends animal{

}
//子类cog继承父类animal
class cat extends animal{

}

2.继承中的成员变量的注意事项

问：如果子父类中出现了重名的成员变量, 在使用的时候, 会优先使用谁?

01. 会根据就近, 优先使用子类自己的成员变量.

02. 如果非要使用父类的成员, 可以使用super进行区分

public class ep{
    String name;
}
class ep1 extends ep{
    public void work() {
        //此处就用super使用了父类的成员
      System.out.println("姓名为："+super.getName());
    }
}

3. 继承中的成员方法注意事项

方法重写 (Override) :

01在子类和父类中出现了方法声明一模一样的方法 ( 方法名, 参数, 返回值 完全一致)

注：方法重写, 又叫做方法的覆盖重写.

问：什么时候子类需要对父类的方法进行重写呢 ?

01.子类在继承父类时, 不希望完全继承, 想做一些修改的话, 就可以进行方法重写

02.父类中 private 私有的方法子类无法重写（无法访问自然无法重写）

03.子类重写父类方法的时候, 访问权限,必须大于等于父类.

private < default < protected < public

4.继承的特点

只支持单继承，不支持多继承，可以多层继承

5.继承中的构造方法

子类在初始化之前, 必须先完成父类的初始化

案例 ：

public  class TextEmployee {
    public static void main(String[] args) {
        Manager qw =new Manager("隔壁老王",34,18888,30);
        qw.work();
    }
}
		//父类
 class  Employee {
    private String name;
    private int age;
    private int score;

    public  void work(){
     System.out.println("在干嘛！")
    }
   		 //空参构造
    public Employee() {
    }

		//带参构造
    public Employee(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
		
		// JavaBean(Set、Get方法)的编写
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}
		//子类1
class coder extends Employee {
    public coder() {
    }

    public coder(String name, int age, int score) {
        super(name, age, score);
    }
    public void work() {
        System.out.println("姓名为" + super.getName() + "年龄为" + super.getAge() + "，工资为" + super.getScore() + "的热心市民正在打羽毛球。");
    }
}
			//子类2
class Manager extends Employee{
    private int price;

    public Manager() {
    }

    public Manager(String name, int age, int score, int price) {
        super(name, age, score);
        this.price = price;
    }

    public void work() {
        System.out.println("姓名为" + super.getName() + "，年龄为" + super.getAge() + "，工资为" + super.getScore() + "，奖金为" + price + "的五好青年正在烧饭。");
    }
    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

6.this和super的区别

this : 调用本类成员 (变量, 方法, 构造方法)

01.this.本类成员变量;

02.this.本类成员方法(实际参数);

03.this(…);

super : 调用父类成员 (变量, 方法, 构造方法)

01.super.父类成员变量

02.super.父类成员方法(实际参数);

03.super(…);

7.final关键字

final 是一个修饰符

1.方法 : 不能被重写

2.类 : 可以有父类，但不可能有子类。

3.变量 : 只能赋值一次, 不能再次修改

8.抽象类

01.抽象方法的定义格式:

public abstract void fy();

02.抽象类的定义格式:

public abstract class fy2 {};

注：抽象类不能创建对象，抽象类可以没有抽象方法，但有抽象方法的类一定是抽象类.

9.abstract与private与static

1.final ：被abstract修饰的方法强制要求子类重写，被final修饰的方法子类不能重写

2.private：被abstract修饰的方法强制要求子类重写，被 private 修饰的方法子类不能重写

3.static：被static修饰的成员可以类名调用，而类名调用一个没有方法体的抽象方法，没有意义