文章目录
1、抽象类
1.1、引出问题
package Abstract01;
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();
}
1.2、定义
1.3、注意事项和细节讨论
- 抽象类不能被实例化
- 抽象类不一定要包含abstract方法,也就是说,抽象类可以没有abstract方法
- 一旦类包含了abstract方法,则这个类必须声明为abstract
- abstract 只能修饰类和方法,不能修饰属性和其他
- 抽象类可以有任意成员【抽象类本质还是类】,比如:非抽象方法、构造器、静态属性等
- 抽象方法不能有主体,即不能实现【不能有方法的大括号】
- 如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类
第 1 - 4点的代码说明
package Abstract01;
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
// class B { // 报错
abstract class B {
public abstract void hi();
}
// abstract 只能修饰类和方法, 不能修饰属性和其它的
class C {
// public abstract int n1 = 1; // 报错
}
第 5 - 7点的代码说明
package Abstract01;
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 = "韩顺平教育";
public void hi() {
System.out.println("hi");
}
public abstract void hello();
public static void ok() {
System.out.println("ok");
}
}
1.4、设计题
编写一个Employee类,声明为抽象类,包含如下三个属性:name,id,salary,提供必要的构造器和抽象方法:work(),对于Manager类来说,他既是员工,还具有奖金(bonus)的属性,请使用继承的思想,设计CommonEmployee类和Manager类,要求类中提供必要的方法进行属性访问,实现work(),提示“经理/普通员工 名字 工作中…” 【使用 oop的继承 + 抽象类】
Exec.java
package Abstract01;
/*
编写一个Employee类,声明为抽象类,包含如下三个属性:name,id,salary,
提供必要的构造器和抽象方法:work(),
对于Manager类来说,他既是员工,还具有奖金(bonus)的属性,
请使用继承的思想,设计CommonEmployee类和Manager类,
要求类中提供必要的方法进行属性访问,实现work(),提示“经理/普通员工 名字 工作中...” 【使用 oop的继承 + 抽象类】
*/
abstract public class Exec {
public static void main(String[] args) {
Manager manager = new Manager("张三", 100, 24000, 5000);
manager.work();
CommonEmployee commonEmployee = new CommonEmployee("李四", 200, 5500);
commonEmployee.work();
}
}
abstract class Employee {
private String name;
private int id;
private double 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;
}
public Employee(String name, int id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
abstract public void work();
}
Manager.java
package Abstract01;
public class Manager extends Employee {
private double bonus;
public Manager(String name, int id, double salary, double bonus) {
super(name, id, salary);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理" + getName() + "正在工作...");
}
}
CommonEmployee.java
package Abstract01;
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() + "正在工作...");
}
}
1.5、抽象类最佳实践(模板设计模式)
1.5.1、定义
抽象类体现的就是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式
1.5.2、板设计模式解决的问题
- 当功能内部一部分实现是确定,一部分实现是不确定的,这时可以把不确定的部分暴露出去,让子类去实现
- 一个抽象父类,父类提供了多个子类的通用方法,并把一个或多个方法留给其子类实现,就是一种模板模式
1.5.3、最佳实践
- 有多个类,完成不同的任务job
- 要求统计得到各自完成任务的时间
Template.java
package 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.java
package abstract_;
public class AA extends Template {
// 计算任务
// 1+....+ 800000
@Override
public void job() { // 实现 Template 的抽象方法 job
long num = 0;
for (long i = 1; i <= 8000000; 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.java
package abstract_;
public class BB extends Template{
public void job() {//这里也去,重写了 Template 的 job 方法
long num = 0;
for (long i = 1; i <= 800000; i++) {
num *= i;
}
}
}
TestTemplate.java
package abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime(); // 对多态需要有良好的 OOP 基础
BB bb = new BB();
bb.calculateTime();
}
}
2、接口
2.1、引出接口
UsbInterface.java
package interface_;
public interface UsbInterface { // 接口
// 规定接口的相关方法
public void start();
public void stop();
}
Camera.java
package interface_;
// Camera 类需要实现 UsbInterface 接口 规定/声明的方法
public class Camera implements UsbInterface { // 实现接口, 就是把接口方法实现
@Override
public void start() {
System.out.println("相机开始工作...");
}
@Override
public void stop() {
System.out.println("相机停止工作...");
}
}
Phone.java
package interface_;
// Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作...");
}
}
Computer.java
package interface_;
public class Computer {
// 编写一个方法, 计算机工作
// 1. UsbInterface usbInterface 形参是接口类型 UsbInterface
// 2. 看到 接收 实现了 UsbInterface接口的类的对象实例
public void work(UsbInterface usbInterface) {
usbInterface.start();
usbInterface.stop();
}
}
Interface01.java
package interface_;
public class Interface01 {
public static void main(String[] args) {
// 创建手机, 相机对象
// Camera 实现了 UsbInterface
Camera camera = new Camera();
// Phone 实现了 UsbInterface
Phone phone = new Phone();
// 创建计算机
Computer computer = new Computer();
computer.work(camera); // 把相机接入到计算机
computer.work(phone); // 把手机接入到计算机
}
}
2.2、接口定义
2.3、深入讨论
DBInterface.java
package interface_;
public interface DBInterface {
public void connect(); // 连接方法
public void close(); // 关闭连接
}
MysqlDB.java
package interface_;
public class MysqlDB implements DBInterface {
@Override
public void connect() {
System.out.println("连接 mysql");
}
@Override
public void close() {
System.out.println("关闭 mysql");
}
}
OracleDB.java
package interface_;
public class OracleDB implements DBInterface {
@Override
public void connect() {
System.out.println("连接 oracle");
}
@Override
public void close() {
System.out.println("关闭 oracle");
}
}
Interface03.java
package interface_;
public class Interface03 {
public static void main(String[] args) {
MysqlDB mysqlDB = new MysqlDB();
t(mysqlDB);
OracleDB oracleDB = new OracleDB();
t(oracleDB);
}
public static void t(DBInterface dbInterface) {
dbInterface.connect();
dbInterface.close();
}
}
2.4、注意事项和细节
- 接口不能被实例化
- 接口中所有的方法都是public,接口中抽象方法,可以不用abstract修饰
- 一个普通类实现接口,就必须将该接口的所有方法都实现
- 抽象类实现接口,可以不用实现接口的方法
- 一个类同时可以实现多个接口
- 接口中的属性,只能是final的,而且是public static final 修饰符,比如:int a=1;实际上是 public static final int a=1;(必须初始化)
- 接口中属性的访问形式:接口名.属性名
- 接口不能继承其它的类,但是可以继承多个别的接口,比如:interface A extends B, C{}
- 接口的修饰符只能是public和默认,这点和类的修饰符是一样的
第 1 - 4点的代码说明
package interface_;
public class InterfaceDetail01 {
public static void main(String[] args) {
// new IA(); // 报错
}
}
// 1.接口不能被实例化
// 2.接口中所有的方法是 public 方法, 接口中抽象方法, 可以不用 abstract 修饰
// 3.一个普通类实现接口, 就必须将该接口的所有方法都实现, 可以使用 alt+enter 来解决
// 4.抽象类去实现接口时, 可以不实现接口的抽象方法
interface IA {
void say(); // 修饰符 public protected 默认 private
void hi();
}
class Cat implements IA{
@Override
public void say() {
}
@Override
public void hi() {
}
}
abstract class Tiger implements IA {
}
第 5 - 9点的代码说明
package interface_;
public class InterfaceDetail02 {
public static void main(String[] args) {
// 接口中的属性, 是 public static final
System.out.println(IB.n1); // 说明 n1 就是 static
// IB.n1 = 30; 说明 n1 是 final
}
}
interface IB {
// 接口中的属性, 只能是 final 的, 而且是 public static final 修饰符
int n1 = 10; // 等价 public static final int n1 = 10;
void hi();
}
interface IC {
void say();
}
// 接口不能继承其它的类, 但是可以继承多个别的接口
interface ID extends IB, IC {
}
// 接口的修饰符 只能是 public 和 默认, 这点和类的修饰符是一样的
interface IE {
}
// 一个类同时可以实现多个接口
class Pig implements IB, IC {
@Override
public void hi() {
}
@Override
public void say() {
}
}
2.5、实现接口 vs 继承类
package interface_;
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey sun = new LittleMonkey("孙悟空");
sun.climbing();
sun.swimming();
sun.flying();
}
}
class Monkey {
private String name;
public void climbing() {
System.out.println(name + "会爬树...");
}
public Monkey(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
interface Fishable {
void swimming();
}
interface Birdable {
void flying();
}
class LittleMonkey extends Monkey implements Fishable, Birdable {
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println(getName() + "通过学习, 学会了游泳...");
}
@Override
public void flying() {
System.out.println(getName() + "通过学习, 学会了飞翔...");
}
}
小结:当子类继承了父类,就自动的拥有父类的功能,如果子类需要扩展功能,可以通过实现接口的方式扩展,可以理解 实现接口 是 对 java 单继承机制的一种补充
2.6、接口的多态特性
InterfacePolyParameter.java
package PolyParameter;
public class InterfacePolyParameter {
public static void main(String[] args) {
// 接口的多态体现
// 接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
IF if01 = new Monster();
if01 = new Car();
// if01 = new AAA(); // 报错
// 继承体现的多态
// 父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
AAA a = new BBB();
a = new CCC();
}
}
interface IF {
}
class Monster implements IF {
}
class Car implements IF {
}
class AAA {
}
class BBB extends AAA {
}
class CCC extends AAA {
}
InterfacePolyArr.java
package PolyParameter;
public class InterfacePolyArr {
public static void main(String[] args) {
// 多态数组 -> 接口类型数组
Usb[] usbs = new Usb[2];
usbs[0] = new Phone_();
usbs[1] = new Camera_();
/*
给 Usb 数组中, 存放 Phone 和 相机对象, Phone 类还有一个特有的方法 call(),
遍历 Usb 数组, 如果是 Phone 对象, 除了调用 Usb 接口定义的方法外,
还需要调用 Phone 特有方法 call
*/
for (int i = 0; i < usbs.length; i++) {
usbs[i].work(); // 动态绑定... // 和前面一样, 我们仍然需要进行类型的向下转型
if (usbs[i] instanceof Phone_) { // 判断他的运行类型是 Phone_
((Phone_) usbs[i]).call();
}
}
}
}
interface Usb {
void work();
}
class Phone_ implements Usb {
public void call() {
System.out.println("手机可以打电话...");
}
@Override
public void work() {
System.out.println("手机工作中...");
}
}
class Camera_ implements Usb {
@Override
public void work() {
System.out.println("相机工作中...");
}
}
InterfacePolyPass.java
package PolyParameter;
public class InterfacePolyPass {
public static void main(String[] args) {
// 接口类型的变量可以指向, 实现了该接口的类的对象实例
IG ig = new Teacher();
// 如果 IG 继承了 IH 接口, 而 Teacher 类实现了 IG 接口
// 那么, 实际上就相当于 Teacher 类也实现了 IH 接口
// 这就是所谓的 接口多态传递现象
IH ih = new Teacher();
}
}
interface IH {
void hi();
}
interface IG extends IH {
}
class Teacher implements IG {
@Override
public void hi() {
}
}