day03_继承_抽象类

继承

继承：描述的是类与类之间都关系

继承的优势：当在程序如果有多个类存在有共同属性和功能的时候，可以把共有都提取到父类中，提高代码复用性，减少代码量。

当子类继承父类时，子类就会自动获取父类中的属性和方法

Java只允许单继承，不能多继承

一个类只能直接继承一个类，不能直接继承多个类

允许一个类有多个子类，但是不允许一个类有多个父类（<=2）

在程序中一旦声明咯一个普通类，自动继承object类

在父类中都属性私有化  对于子类来说不能直接使用，通过getter和setter方法来实现

如果在子类中重写了父类的方法，在子类中调用该方法时，调用的是子类重写之后都方法。

子类重写父类中的方法，那么在子类中必须按照父类中的方法语法格式进行编写。（返回值类型不能改，方法名称不能修改，方法参数不能修改，访问权限可以变，但是必须子类权限不能小于父类，一般权限修饰符不改动）

如果我们在子类中的方法上添加@override 那么要求父类中必须有该方法    @override为增强编译性、规范性

子类重写方法之后，想在子类中调用父类中的方法，用super关键字   super和static不能共存

/*

定义一个父类People,定义一个属性weight,定义一个

 

方法eat有一个参数表示吃了多少,每吃一次,体重增加

相应的值.定义一个Man是People的子类,定义一个属

性是Woman类型叫做女朋友,定义一个属性叫工资.定

义一个sport方法,没有参数,运动一次体重减少5,父类

中eat方法的功能Man中不变,如果体重超过200,调用

一下sport方法.写一个方法lol,男人每玩一次lol,他的女

朋友调用自己购物方法去shopping定义一个Woman,

是People的子类,定义一个属性是Man类型叫男朋友,

定义一个方法shopping,女人每调用一次shopping,男

朋友的工资减100

*/

public class People {

    private double weight;

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void eat(double food){

        weight+=food;

    }

}

public class Man extends People {

    private Women gf;
    private double salary;

    public Women getGf() {
        return gf;
    }

    public void setGf(Women gf) {
        this.gf = gf;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void sport() {
        setWeight(getWeight() - 5);
    }

    @Override
    public void eat(double food) {
        super.eat(food);
        if (getWeight() > 200) {
            sport();
        }
    }

    public void lol(){
        gf.shopping();
    }

}

public class Women extends People{

    private Man bf;

    public Man getBf() {
        return bf;
    }

    public void setBf(Man bf) {
        this.bf = bf;
    }

    public void shopping(){
        bf.setSalary(bf.getSalary()-100);
    }
}

 

public class Main {
    public static void main(String[] args) {
        Man bf = new Man();
        Women gf = new Women();
        bf.setSalary(5000);
        bf.setWeight(190);
        //吃饭
        bf.eat(11);//201
        bf.setGf(gf);
        gf.setBf(bf);
        bf.lol();
        System.out.println(bf.getSalary());
        System.out.println(bf.getWeight());
    }
}

 

 

 

 

抽象类

本质还是类，定义一个父类的时候,有些方法可能需要子类去做具体的功能,而在父类中并不能确定做哪些功能,那么我们就可以将这些方法定义成抽象方法.所谓的抽象方法就是没有方法体的方法.那么我们的类也必须定义这个类为抽象的类

抽象方法都特征是以分号为结尾 如： public void eat() ;

普通方法特征是以｛｝(作用域)为结尾  如： public  void eat(){}

对于普通类来说，不能存放抽象方法

只能在抽象类中声明抽象方法   abstract

在类的前面添加abstract关键字，该类就变成咯抽象类

在方法的前面添加abstract关键字，该方法变成咯抽象方法

在程序中一般情况下会把抽象类定义成父类，会有很多子类

当子类继承抽象类时，要求子类必须重写父类都全部抽象方法。

在抽象类中既可以声明抽象的方法，也可以声明普通成员方法

子类不用重写抽象类中的普通成员方法

抽象关键字abstract不可以和哪些关键字共存？

1. private：私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。

2. final:因为被final定义的方法不能被重写,而抽象方法需要子类去重写进行实现功能,所以矛盾

3. static:因为static不用实例化可直接调用,即当前类就直接能够调用了,而abstract需要子类实现后才能调用,所以矛盾

 

/*

定义一个类是员工,员工有id和name属性,有一个方法

是eat调用eat所有员工输出吃饭,有一个抽象方法是

work,不同的员工工作的内容不同,定义3个类,程序员,

老师,网管,分别调用work的时候”id为xx的name写代

码”,”讲课”,”拉网线

*/

public abstract class Employee {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public void eat(){
        System.out.println("吃饭");
    }

    public abstract void word();

    class Programmer  extends Employee{
        @Override
        public void word() {
            System.out.println("id为"+getId()+"的"+ getName()+"写代码");
        }
    }

    class NetworkManagement extends Employee {
        @Override
        public void word() {
            System.out.println("id为"+getId()+"的"+ getName()+"拉网线");
        }
    }

     class Teacher extends Employee {
        @Override
        public void word() {
            System.out.println("id为"+getId()+"的"+ getName()+"讲课");
        }
    }
}

 

 

 

 

接口

1. 接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。

2. 接口中只允许出现抽象方法,不能出现非抽象方法

3. 接口的源文件也是java文件,编译后的文件也是.class,所以可以把接口看作一个特殊的类

4.JDK1.8 之后，能放默认方法（default）和静态方法（static），有方法体，不允许声明普通方法

5.接口中不能声明变量，只能是公共的静态常量

常量  在声明都时候，必须初始化，常理名称全部大写  public final 数据类型 常量名 = 常量值

变量  在声明的时候，没有要求，当使用它时，必须初始化