抽象类的使用
目录
什么是抽象类
抽象类的基本介绍
抽象类的注意事项和使用细节
抽象类习题
第一题
第二题
抽象模板设计模式
什么是抽象类
当父类的一些方法不能确定时，可以用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 {
//重写父类的抽象方法
@Override
public 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方法，则这个类必须声明为abstract
4)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);
}
@Override
void 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);
}
@Override
void 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);
}
@Override
void 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{
@Override
public void job() {
long sum=0;
for (long i = 0; i < 1000000; i++) {
sum+=i;
}
}
}
BBB类
package idea.chapter10.abstract_;
public class BBB extends Template {
@Override
public 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();
}
}