目录

什么是抽象类

抽象类的基本介绍

抽象类的注意事项和使用细节

抽象类习题

第一题

第二题

抽象模板设计模式

什么是抽象类

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

抽象类的基本介绍

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

访问修饰符 abstract 类名{

}

2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型 方法名(参数列表)；//没有方法体

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

代码演示：

package idea.chapter10.abstract_;/*** 演示抽象类的基本使用*/
public class abstract01 {public static void main(String[] args) {/*什么是抽象类当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。抽象类的基本介绍1)用abstract关键字来修饰一个类时，这个类就叫抽象类访问修饰符 abstract 类名{}2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型 方法名(参数列表)；//没有方法体3)抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()*/}
}/*** 注意当一个类中有一个方法是abstract修饰的，那么这个类就一定要是抽象类*///这就是一个抽象类
abstract class A {//2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型 方法名(参数列表)；// 没有方法体public abstract void hi();
}//继承A类
class B extends A {//重写父类的抽象方法@Overridepublic void hi() {}}

抽象类的注意事项和使用细节

1)抽象类不能被实例化 [举例]

2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法[举例]

3)一旦类包含了abstract方法，则这个类必须声明为abstract [说明]

4)abstract只能修饰类和方法，不能修饰属性和其它的。[说明]

代码演示：

package idea.chapter10.abstract_;/*** 演示抽象类的注意事项和使用细节1*/
public class abstractDetail01 {public static void main(String[] args) {/*抽象类的注意事项和使用细节1)抽象类不能被实例化2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法3)一旦类包含了abstract方法，则这个类必须声明为abstract4)abstract只能修饰类和方法，不能修饰属性和其它的*///1)抽象类不能被实例化//此时AA是一个抽象类，因为抽象类不能被实例化，所以当我们想去实例化一个抽象类的时候就会报错//AA aa = new AA();//这是错误的}
}//定义了一个抽象类
abstract class AA {//4)abstract只能修饰类和方法，不能修饰属性和其它的//abstract 只能修饰类和方法，不能修饰属性和其它的//abstract int n1;//abstract void hi();//2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法//这样也是正确的public void say() {}
}//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class C {public abstract void hi();
}

5)抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等[举例]

6)抽象方法不能有主体，即不能实现.如图所示

7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类，B类，C类]

8)抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。

代码演示：

package idea.chapter10.abstract_;/*** 演示抽象类的注意事项和使用细节2*/
public class abstractDetail02 {public static void main(String[] args) {/*5)抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等6)抽象方法不能有主体，即不能实现.7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类，B类，C类]8)抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。*/}
}abstract class BB {//5)抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等private String name;private int age;//静态属性private static double sum;//构造器public BB(String name, int age) {this.name = name;this.age = age;}//非抽象方法public void hi() {}//抽象方法不能有主体，即不能实现//这样是错误的，不能实现
//    abstract void say(){
//        System.out.println();
//    }//这样才是正确的abstract void say();}//因为cc继承了BB类所以需要实现BB类中的抽象方法
class CC extends BB {public CC(String name, int age) {super(name, age);}@Overridevoid say() {}
}//如果类的本身就是抽象方法就不用实现父类的抽象方法
abstract class DD extends BB {public DD(String name, int age) {super(name, age);}
}//抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。
abstract class EE {abstract public void hi01();abstract protected void hi02();abstract void hi03();//这个是错误的，不用使用private,final,static修饰//abstract private void hi04();//abstract static void hi05();//abstract final void hi06();
}

抽象类习题

第一题

思路分析：

抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的

//1)题1，思考：abstract final class Af{}译通过吗，why?
// 因为抽象类和final不能一起出现
//2)题2，思考：abstract public static void test2(0；能编译通过吗，why?//不能 因为抽象类和static一起出现
// 3，思考：abstract private void test3(0;能编译通过吗，why?//因为抽象类和private 不能一起出现 

第二题

思路分析：

1.因为Employee类是一个抽象类也是父类，所以在子类去继承父类 时候，不仅要实现父类的抽象方法，也要指定构造器，因为父类的无参构造器被覆盖了

abStractExercise类

package idea.chapter10.abstract_;/*** 演示抽象类的习题*/
public class abstractExercise {public static void main(String[] args) {
//        4)编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。
//        提供必要的构造器和抽象方法：work()。对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。
//        请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问，实现work()，提示“经理/普通员工 名字 工作中....”Manager manager = new Manager("jack", 10, 1000);manager.work();CommonEmployee tom = new CommonEmployee("tom", 20, 100);tom.work();}
}

CommonEmployee类

package idea.chapter10.abstract_;public class CommonEmployee extends Employee {public CommonEmployee(String name, int id, double salary) {super(name, id, salary);}@Overridevoid work() {System.out.println("工人" + super.getName() + "工作中");}
}

Employee类

package idea.chapter10.abstract_;abstract class Employee {private String name;private int id;private double salary;public Employee(String name, int id, double salary) {this.name = name;this.id = id;this.salary = salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}abstract void work();
}

Manager类

package idea.chapter10.abstract_;public class Manager extends Employee {private double bonus;public Manager(String name, int id, double salary) {super(name, id, salary);}@Overridevoid work() {System.out.println("经理" + super.getName() + "工作中");}
}

抽象模板设计模式

思路分析：

Template类

package idea.chapter10.abstract_;/*** 抽象类模板时间模式*/
abstract public class Template {public abstract void job();//因为在这段代码中，许多类都有相同的代码，为了提高代码的复用性，所以我们将相同的代码做成一个方法，然后把不同的代码设计成一个抽象方法，当子类去继承父类的时候，只需要实现抽象方法即可，并调用对应方法public void calculateTime() {//实现方法，调用job方法//得到开始的时间long start = System.currentTimeMillis();job(); //动态绑定机制//得的结束的时间long end = System.currentTimeMillis();System.out.println("任务执行时间 " + (end - start));}
}

AAA类

package idea.chapter10.abstract_;public class AAA extends Template{@Overridepublic void job() {long sum=0;for (long i = 0; i < 1000000; i++) {sum+=i;}}
}

BBB类

package idea.chapter10.abstract_;public class BBB extends Template {@Overridepublic void job() {long sum = 0;for (long i = 0; i < 1000000; i++) {sum += i;}}
}

test类

package idea.chapter10.abstract_;public class test {public static void main(String[] args) {AAA aaa = new AAA();aaa.job();BBB bbb = new BBB();bbb.job();}
}