网站导航
> 文章列表 > 抽象类，接口

抽象类，接口

网友: 文章列表 2024-03-21 17:23:48

抽象类，接口

  1. 抽象类：当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。
  2. package com.hspedu.abstract_;public class Abstract01 {public static void main(String[] args) {}
}
abstract class Animal{//抽象类private String name;public Animal(String name) {this.name = name;}//父类方法不确定性的问题//该方法设计为抽象(abstract)方法//所谓抽象方法就是没有实现的方法//所谓没有实现就是指没有方法体。//当一个类中存在抽象方法时，需要将该类声明为abstract类//一般来说，抽象类会被继承，由子类实现抽象方法//    public void eat(){
//        System.out.println("这是一个动物，但是不知道吃什么...");
//    }public abstract void eat();
}

    抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类（）。抽象类面试好问，在框架和设计模式使用较多。

  3. 抽象类细节

    1. 抽象类不能实例化

    2. 抽象类不一定包含abstract方法。可以没有抽象方法，可以有普通方法

    3. 一旦含有抽象（abstract）方法，这个类必须声明为抽象类。

    4. abstract只能修饰类和方法，不能修饰属性和其它的。

    5. 抽象类可以有任意成员【抽象类还是类】

    6. 抽象方法不能有主体{}

    7. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

    8. package com.hspedu.abstract_;public class Abstract02 {public static void main(String[] args) {}
}
abstract class AA{public abstract void eat();
}class BB extends AA{@Overridepublic void eat() {System.out.println("食草动物吃草...");}
}

      子类实现抽象方法就是有主体{}。

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

    10. final类是不能被继承，final方法不希望被子类修改，抽象方法不就是父类只写方法不写主体{}，然后通过子类来重写吗！

    11. private是私有的方法怎么去重写呢

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

    package com.hspedu.abstract_.template_;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));}
}
class AA extends Template{//父类是抽象的，要么子类也是抽象的，要么重写父类的抽象方法@Overridepublic void job() {long sum=0;for (int i = 1; i <= 100000; i++) {sum+=i;}}
}
class BB extends Template{@Overridepublic void job() {long sum=0;for (int i = 1; i <= 80000; i++) {sum*=i;}}
}
class TemplateTest{public static void main(String[] args) {AA aa = new AA();aa.calculateTime();BB bb = new BB();bb.calculateTime();}}
/*
输出
任务执行时间2
任务执行时间2*/

  5. 接口入门

    package com.hspedu.interface_;public interface UsbInterface {//接口public void start();//这是抽象方法public void stop();
}

    package com.hspedu.interface_;//Person 类实现UsbInterface
public class Phone implements UsbInterface{//实现接口，就是把接口的方法实现@Overridepublic void start() {System.out.println("手机开始工作..");}@Overridepublic void stop() {System.out.println("手机停止工作..");}
}

    package com.hspedu.interface_;public class Computer {//编写一个方法，计算机工作public void work(UsbInterface usbInterface){//通过接口来调用方法usbInterface.start();usbInterface.stop();}
}

    package com.hspedu.interface_;public class ComputerTest {public static void main(String[] args) {//创建手机Phone phone = new Phone();//创建计算机Computer computer = new Computer();computer.work(phone);//把手机接入到计算机}
}
/*
手机开始工作..
手机停止工作..
*/

    接口就是给出一些没有实现的方法，封装在一起，到某个类要使用的时候，在根据具体情况把这些方法写出来

  6. package com.hspedu.interface_;public interface Ainter01 {//抽象方法public void say();//默认 ，jdk7和之前只能在接口中定义抽象方法default public void hi(){}//jdk8后可以定义默认还有静态方法public static void see(){}}

    在接口中静态默认方法也能定义default

  7. 接口注意事项

    1. 接口不能被实例化

    2. 接口中所有的方法是public方法（如果不写public还是public的，不会是默认的），接口中抽象方法，可以不用abstract修饰。

    3. 一个普通类实现接口，就必须将该接口的所有方法都实现

    4. 抽象类实现接口，可以不用实现接口的方法

    5. 一个类同时可以实现多个接口

    6. 接口中的属性，只能是final的，而且是public static final 修饰符。比如：int a=1;实际上是public static final int a = 1;（必须初始化）

    7. 接口中属性的访问形式：接口名.属性名

    8. 接口不能继承其他的类，但是可以继承多个别的接口。

    9. 接口的修饰符只能是public 和默认，这点和类的修饰符是一样的

    10.  都正确，B实现A。

  8. 接口VS继承

    1. 继承当子类继承了父类，就自动的拥有父类的功能

    2. 如果子类需要扩展功能，可以通过实现接口的方式扩展。

    3. 接口比继承更加灵活，

    4. 接口在一定程度上实现代码解耦（？接口规范性+动态绑定机制）

  9. 接口的多态特性

    1. 多态参数（实现了A接口的类，就能把该类传进形参是A接口（Phone实现了接口））

      package com.hspedu.interface_;public class Inter02 {public static void main(String[] args) {//接口类型的变量monster可以指向实现IA接口的对象实例IA monster = new Monster();}
}
interface IA{}
class Monster implements IA{}
class Car implements IA{}

      接口引用可以指向实现了接口的类的对象

    2. 多态数组

      package com.hspedu.interface_;public class Inter03 {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("手机可以打电话...");}@Overridepublic void work() {System.out.println("手机工作中...");}
}
class Camera_ implements Usb{@Overridepublic void work() {System.out.println("相机工作中....");}
}

      怎么实现特有的方法

    3. 接口存在多态传递现象

      1. package com.hspedu.interface_;
//演示多态传递现象
public class Inter04 {public static void main(String[] args) {//接口类型的变量可以指向，实现了该接口的类的对象实例IG ig = new Teacher();IH ih = new Teacher();//不会报错，}
}
interface IH{void hi();
}
interface IG extends IH{//如果这没有继承，那么IH接口类型的变量不会指到Teacher类对象的}
class Teacher implements IG{//通过上面的继承，这个Teacher也实现了IH接口@Overridepublic void hi() {}
}

        接口多态传递

网络标签：

相关问题