2019-05-27 java学习日记

面向对象

抽象(abstract)类的概述：抽象就是看不懂的

抽象类的特点

1，抽象类和抽象方法必须用 abstract 关键字修饰

抽象类：abstract class 类名 {}
抽象方法：public abstract void eat（）；

2，抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

3，抽象类不能实例化，那么抽象类如何实例化呢？

按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态

抽象类的子类：

1，要么是抽象类
2，要么重写抽象类中的所有抽象方法

例子

class Demo1_Abstract {
　　public static void main(String[] args) {
　　//Animal a = new Animal(); //错误: Animal是抽象的; 无法实例化
　　Animal a = new Cat(); //父类引用指向子类对象
　　a.eat();
　　}
}

abstract class Animal { //抽象类
　　public abstract void eat(); //抽象方法

public Animal() {
　　System.out.println("父类空参构造");
}
}

class Cat extends Animal {
　　public Cat() {
　　super();
}
public void eat() {
　　System.out.println("鱼吃猫");
　　}
}

抽象类的成员特点

特点

1，成员变量：即可以是变量，也可以是常量，
      abstract不能修饰成员变量

2，构造方法：用于子类访问父类数据的初始化

3，成员方法：即可以是抽象的，也可以是非抽象的

抽象类的成员方法特性

1，抽象方法：强制要求子类做的事情
如：重写方法。

2，非抽象方法：子类继承的事情，提高代码的复用性。

例子

abstract class Demo {
　　int num1 = 10;
　　final int num2 = 20;

public Demo(){}

　　public void print() {
　　　　System.out.println("111");
}

　　public abstract void method();
}

class Test extends Demo {
　　public void method() {
　　　　System.out.println("111");
　　}
}

class Demo_Teacher {
    public static void main(String[] args) {
        Teacher1 t1 = new Teacher1("王富贵",43);
        System.out.println("姓名：" + t1.getName() + '
' + "年龄：" + t1.getAge());
        t1.print();
        Teacher2 t2 = new Teacher2("陈教授",48);
        System.out.println("姓名：" + t2.getName() + '
' + "年龄：" + t2.getAge());
        t2.print();
    }
}

abstract class Teacher {
    private String name;
    private int age;

    public Teacher() {}
    public Teacher(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public abstract void print() ;
}
class Teacher1 extends Teacher {
    public Teacher1() {}
    public Teacher1(String name,int age) {
        super(name,age);
    }
    public void print() {
        System.out.println("讲基础");
    }
}
class Teacher2 extends Teacher{
    public Teacher2() {}
    public Teacher2(String name,int age) {
        super(name,age);
    }
    public void print() {
        System.out.println("讲就业");
    }

}

abstract不能与以下关键字共存

abstract和static

被abstract修饰的方法没有方法体
被static崔氏的可以用类名.调用,但是类名.调用抽象方法是没有意义的

abstract和final

被abstract修饰的方法强制子类重写
被final修饰的不然让子类重写,所以他俩是矛盾的

abstract和private

被abstract修饰的是为了让子类看到并强制重写
被private修饰的不让子类访问,所以他俩是矛盾的

如：

abstract class Demo {
　　//public static abstract void print(); //错误: 非法的修饰符组合: abstract和static
　　//public final abstract void print(); //错误: 非法的修饰符组合: abstract和final
　　private abstract void print(); //错误: 非法的修饰符组合: abstract和private
}