- 1.抽象类介绍
- 2.抽象类细节
- 3.抽象类细节02
- 4.抽象类实例(员工问题）
- test01.java
- Employee.java
- Manager.java
- CommonEmployee.java
- 5.抽象类-模板设计模式
- 1.普通设计
- 乘法
- 加法
- main函数
- 模板设计模式
- main函数
- 父类
- AA类
- BB类
父类方法不确定性的问题
===> 考虑将该方法设计为抽象（abstract）方法 //===> 所谓抽象方法就是没有实现的方法 //===> 所谓没有实现就是指，没有方法体 //===> 当一个类中存在抽象方法时，需要将该类声明为abstract类 //===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.
package com.demo.abstract_;
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
//思考：这里eat 这里你实现了，其实没有什么意义
//即： 父类方法不确定性的问题
//===> 考虑将该方法设计为抽象(abstract)方法
//===> 所谓抽象方法就是没有实现的方法
//===> 所谓没有实现就是指，没有方法体
//===> 当一个类中存在抽象方法时，需要将该类声明为abstract类
//===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.
// public void eat() {
// System.out.println("这是一个动物，但是不知道吃什么..");
// }
public abstract void eat() ;
}
2.抽象类细节
1.//抽象类，不能被实例化
2. //抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
3.//一旦类包含了abstract方法,则这个类必须声明为abstract
4.//abstract 只能修饰类和方法，不能修饰属性和其它的
package com.demo.abstract_;
public class AbstractDetail01 {
public static void main(String[] args) {
//抽象类，不能被实例化
//new A();
}
}
//抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
abstract class A {
public void hi() {
System.out.println("hi");
}
}
//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
// public abstract int n1 = 1;
}
3.抽象类细节02
1.//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
2.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
3.//抽象类的本质还是类，所以可以有类的各种成员
package com.demo.abstract_;
public class AbstractDetail02 {
public static void main(String[] args) {
System.out.println("hello");
}
}
//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
public abstract void hi();//抽象方法
}
//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
public abstract void hi();
}
abstract class F extends E {
}
class G extends E {
@Override
public void hi() { //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体
}
}
//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
public int n1 = 10;
public static String name = "Demo龙";
public void hi() {
System.out.println("hi");
}
public abstract void hello();
public static void ok() {
System.out.println("ok");
}
}
4.抽象类实例(员工问题）
test01.java
package com.demo.abstract_;
public class test01 {
public static void main(String[] args) {
//测试
Manager jack = new Manager("jack", 999, 50000);
jack.setBonus(8000);
jack.work();
CommonEmployee tom = new CommonEmployee("tom", 888, 20000);
tom.work();
}
}
Employee.java
package com.demo.abstract_;
abstract public 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;
}
//将work做成一个抽象方法
public abstract void work();
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;
}
}
Manager.java
package com.hspedu.abstract_;
public class Manager extends Employee {
private double bonus;
public Manager(String name, int id, double salary) {
super(name, id, salary);
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理 " + getName() + " 工作中...");
}
}
CommonEmployee.java
package com.hspedu.abstract_;
public class CommonEmployee extends Employee{
public CommonEmployee(String name, int id, double salary) {
super(name, id, salary);
}
@Override
public void work() {
System.out.println("普通员工 " + getName() + " 工作中...");
}
}
5.抽象类-模板设计模式
1.普通设计 乘法计算指定算法所需要的时间
public void job1() {
//得到开始的时间
long start = System.currentTimeMillis();
long num = 1;
for (long i = 1; i <= 200000; i++) {
num *= i;
}
//得的结束的时间
long end = System.currentTimeMillis();
System.out.println("AA 执行时间 " + (end - start));
}
加法
public void job2() {
//得到开始的时间
long start = System.currentTimeMillis();
long num = 0;
for (long i = 1; i <= 200000; i++) {
num += i;
}
//得的结束的时间
long end = System.currentTimeMillis();
System.out.println("AA 执行时间 " + (end - start));
}
main函数
package com.hspedu.abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态
BB bb = new BB();
bb.calculateTime();
}
}
测试结果
main函数抽象类模板设计模式，就是在父类中提取出相同的模板，不同的部分抽象化，在子类中重写抽象函数，需要用到OOP中的动态绑定机制
package com.demo.abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态
BB bb = new BB();
bb.calculateTime();
}
}
父类
package com.hspedu.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));
}
}
AA类
package com.hspedu.abstract_;
public class AA extends Template {
//计算任务
//1+....+ 800000
@Override
public void job() { //实现Template的抽象方法job
long num = 0;
for (long i = 1; i <= 800000; i++) {
num += i;
}
}
// public void job2() {
// //得到开始的时间
// long start = System.currentTimeMillis();
// long num = 0;
// for (long i = 1; i <= 200000; i++) {
// num += i;
// }
// //得的结束的时间
// long end = System.currentTimeMillis();
// System.out.println("AA 执行时间 " + (end - start));
// }
}
BB类
package com.hspedu.abstract_;
public class BB extends Template{
public void job() {//这里也去，重写了Template的job方法
long num = 0;
for (long i = 1; i <= 80000; i++) {
num *= i;
}
}
}
测试结果
