抽象类与接口

Rillia

已于 2023-07-01 00:46:26 修改

阅读量41

点赞数

分类专栏：笔记周志文章标签： jvm java 开发语言

于 2023-05-14 09:58:01 首次发布

本文链接：https://blog.csdn.net/m0_74163755/article/details/130665820

版权

笔记周志专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

抽象类

抽象类的介绍
1. 用abstract 关键字来修饰一个类时，这个类就叫抽象类访问修饰符 abstract 类名{}
2. 用abstract 关键字来修饰一个方法时，这个方法就是抽象方法
3. 访问修饰符 abstract 返回类型方法名（参数列表）；//没有方法体
4. 抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现
5. 抽象类（）
6. 抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

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

抽象类不能被实例化
抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法
一旦类包含了abstract方法，则这个类必须声明为abstract
abstract 只能修饰类和方法，不能修饰属性和其它的。
抽象类可以有任意成员【抽象类本质还是类】，比如：非抽象方法、
构造器、静态属性等等 [举例］
抽象方法不能有主体，即不能实现．如图所示
abstract void aaa(){
｝
如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，
除非它自己也声明为abstract类。［举例 A类，B类，C类］
抽象方法不能使用private，final和static来修饰，因为这些关键字都和重写相违背的

/**
*抽象类的使用
*/
public class AbstractDetail02 {
	public static void main(String[] args) {
        System.out.println("hello");
    }
}
   
abstract class H {
        public abstract void hi();
}

abstract class E {
        public abstract void hi();
 }
abstract class F extends E {
 }
class G extends E {
        @Override
        public void hi() { 
	}
}

abstract class D {
	public int n1 = 10;
    public static String name = "kk";
    public void hi() {
    	System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
        System.out.println("ok");
    }
}

抽象类最佳实践-模板设计模式

基本介绍
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
模板设计模式能解决的问题
1)当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分
暴露出去，让子类去实现。
2)编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其
子类实现，就是一种模板模式

/**
*模板设计
*/
abstract public class Template { 
	public abstract void job();
    public void calculateTime() {

        long start = System.currentTimeMillis();
        job(); 
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}

public class AA extends Template {

        @Override
        public void job() { 
        long num = 0;
        for (long i = 1; i <= 800000; i++) {
        num += i;
	}
}

}

public class BB extends Template{
    public void job() {
        long num = 0;
        for (long i = 1; i <= 80000; i++) {
        	num *= i;
        }
    }
}

public class TestTemplate {
	public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime(); /
        BB bb = new BB();
        bb.calculateTime();
        }
}

接口

基本介绍：

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些
方法写出来。语法：
interface 接口名｛
//属性
//抽象方法
class 类名 implements 接口｛
自己属性：
自己方法；
必须实现的接口的抽象方法

}

小结：

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。特别说明：Jdk8.0后接口类可以有静态方法，默认方法也就是说接口中可以有方法的具体实现

/**
*接口快速入门
*/
public interface UsbInterface { 
	 public void start();
     public void stop();
    }

public class Camera implements UsbInterface{
    @Override
    public void start() {
    	System.out.println("相机开始工作...");
    }
    @Override
    public void stop() {
    	System.out.println("相机停止工作....");
    }
}

//Phone 类 实现 UsbInterface

public class Phone implements UsbInterface {
        @Override
        public void start() {
        System.out.println("手机开始工作...");
        }
        @Override
        public void stop() {
        System.out.println("手机停止工作.....");
    }
}
public class Interface01 {
    public static void main(String[] args) {
    
        Camera camera = new Camera();
        Phone phone = new Phone();
        Computer computer = new Computer();
        computer.work(phone);
        System.out.println("===============");
        computer.work(camera);
    }
}

注意细节
1. 接口不能被实例化
2. 接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰图示：
  
  void aaa();
  
  实际上是abstract void aa();
3. 一个普通类实现接口，就必须将该接口的所有方法都实现
4. 抽象类实现接口，可以不用实现接口的方法。
5. 一个类同时可以实现多个接口
6. 接口中的属性，只能是final的，而且是public static final 修饰符。比如：
  int a=1; 实际上是 public static final int a=1;(必须初始化）
7. 接口中属性的访问形式：接口名.属性名
8. 接口不能继承其它的类，但是可以继承多个别的接口
  interface A extends B,C{}
9. 接口的修饰符只能是 public和默认，这点和类的修饰符是一样的。

接口与继承差异

接口和继承解决的问题不同:

继承的价值主要在于：解决代码的复用性和可维护性。

接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法。即更加的灵活。
接口比继承更加灵活

接口比继承更加灵活，继承是满足 is-a的关系，而接口只需满足 like - a的关系。
接口在一定程度上实现代码解耦 [即：接口规范性＋动态绑定机制］

接口的多态性

多态参数 (接口引用可以指向实现了接口的类的对象）
多态数组

接口存在多态传递现象

/**
*接口的多态性
*/
public class InterfacePolyParameter {
    public static void main(String[] args) {

        IF if01 = new Monster();
        if01 = new Car();

        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 {}

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

        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();

        for(int i = 0; i < usbs.length; i++) {
            usbs[i].work();
            if(usbs[i] instanceof 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("相机工作中...");
    }
}

/**
* 演示多态传递现象
*/
public class InterfacePolyPass {
    public static void main(String[] args) {
        IG ig = new Teacher();

    }
}
interface IH {
    void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
        @Override
        public void hi() {
        }
}