java抽象类

抽象类

问题：由于父类的某个方法的不确定性，但是要必须声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

解决之道：抽象类快递入门

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。

案例：看看如何把Animal做成抽象类，并让子类Cat类实现

abstract calss Animal{
	String name;
	int age;
	
	//注意在抽象类中，可以没有抽象方法，但是在抽象方法中必须存在在抽象类中（就是抽象方法的类必须是抽象类）
	public abstract void cry();
}

抽象类的介绍

1. 用abstract关键字来修饰一个时，这个类就叫抽象类

   【访问修饰符 abstract 类名{}】

2. 用abstract关键字来修饰一个方法时，这个方法就是抽象访求

   【访问修饰符 abstract 返回值类型 方法名(参数列表)】[注意是抽象方法不能有方法体，否则会报错]

3. 抽象类的价值更多是用在于设计，是设计者设计好后，让子类继承并实现抽象类

4. 抽象类，在构架和设计模式使用较多

抽象类注意事项和细节说明(八点必须记住)

1.抽象类不能被实例化（就是不能创建对象）

2.抽象类不一定要包含abstract方法，也就是说，抽象类可以没有abstract方法

3.一旦类包含了abstract方法，则这个类必须声明成abstract

4.abstract只能修饰类和方法，不能修饰属性和其它的

5.抽象类可以有任意成员【因为抽象类还是类，只是多了抽象方法】

6.抽象方法不能有主体，即不能实现，如下图：

7.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法【一般使用这样方式解决】，或者它自己也声明成abstract类【就是子类要不实现全部的的抽象方法，或者将自己声明成抽象类】

8.面试题目：抽象方法不能使用private final static来修饰，因为这些关键字都是和重写相违背的

package JAVA面向对象高级部分.abstract_;

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类是不能创建对象的（就是不能实例化）
//        new A();
    }
}

//1.抽象类是不能创建对象的（就是不能实例化）
//2.抽象类中不一定有抽象方法，也就是是说：抽象类中可以没有抽象方法
abstract class A {}

//3.一旦类包含了abstract方法，则这个类必须声明为abstract[就是抽象方法的类必须是抽象类]
//4.abstract关键字只能修饰类和方法，不能修饰属性和其它的
abstract class B {
    public abstract void show();
}

package JAVA面向对象高级部分.abstract_;

public class AbstractDetail02 {
    public static void main(String[] args) {

    }
}

//5.抽象类可以有任意成员【因为抽象类本质还是类，只是多了抽象方法】
abstract class Animal {
    //6.抽象方法不能有主体【就是不能有方法体】
    public abstract void show();
} 

//7.如果一个类继承了抽象类，(1)则它必须实现抽象类的所有抽象方法，(2)或者它自己也声明成abstract类
class  Cat extends Animal {
    //使用方式一：实现了抽象类中的所有抽象方法
    @Override
    public void show() {
        System.out.println("我是一只猫！！！"); 
    }
}
//使用方式二：将自己声明成抽象方法
abstract class Dog extends Animal {}

//面试题：抽象方法不能使用private final static 来修饰
abstract class Person {
    //8.关键字abstract不能与private final static相互共存，因为违背了重写
    public abstract void print();
}

练习题目

1.思考：abstract final class A{} 能编译通过吗？//不能，因为abstract与final不能相互共存，final不能继承，而abstract要求要继承否则没有价值

2.思考：abstract public static void test(); 能编译通过吗？//不能，因为abstract与static不能相互共存

3.思考：abstract private void test03();能编译通过吗？//不能，因为abstract与private不能相与共存，而abstract要求要子类重写，而private修饰子类不能使用，更谈不上重写了


4.
/**
 * 编写一个Employee类，声明为抽象类，包含字段:name,id,salary
 * 提供必要的构造器和抽象方法：work().
 * 对manager类来说：他既是员工，还有奖金【bonus】的属性，请使用继承的思想，
 * 设计CommonEmployee类和Manager类，要求类中提供必须的方法进行属性访问，实现work(),
 * 提示‘经理，普通员工名字  工作中’
 */

package JAVA面向对象高级部分.abstract_.exercise;

public class AbstractExercise01 {
    public static void main(String[] args) {
        Manager hai = new Manager("海康", "1008611", 68168.66688, 10000);
        CommonEmployee employee = new CommonEmployee("湛江", "1008612", 31688);
        System.out.println(hai.toString());
        System.out.println(employee.toString());
    }
}

/**
 * 编写一个Employee类，声明为抽象类，包含字段:name,id,salary
 * 提供必要的构造器和抽象方法：work().
 * 对manager类来说：他既是员工，还有奖金【bonus】的属性，请使用继承的思想，
 * 设计CommonEmployee类和Manager类，要求类中提供必须的方法进行属性访问，实现work(),
 * 提示‘经理，普通员工名字  工作中’
 */
abstract class Employee {
    private String name;
    private String id;
    private double salary;

    public Employee() {
    }

    public Employee(String name, String id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    //抽象方法work
    public abstract void work();

    @Override
    public String toString() {
        return
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", salary=" + salary;
    }
}

//Manager类
class Manager extends Employee {
    private int bonus;

    public Manager(int bonus) {
        this.bonus = bonus;
    }

    public Manager(String name, String id, double salary, int bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("经理是人渣！！！呵呵");
    }

    @Override
    public String toString() {
        return "Manager{" + super.toString()+
                "bonus=" + bonus +
                '}';
    }
}

//CommonEmployee类
class CommonEmployee extends Employee {

    public CommonEmployee() {
    }

    public CommonEmployee(String name, String id, double salary) {
        super(name, id, salary);
    }

    @Override
    public void work() {
        System.out.println("普通员工在摸鱼！！！呵呵");
    }

    @Override
    public String toString() {
        return "CommonEmployee{"+super.toString()+"}";
    }
}