（javaSE）抽象类和接口：抽象类概念语法和特性， 抽象类的作用；接口的概念 接口特性 实现多个接口 接口间的继承 Object类

目录

抽象类概念

抽象类语法和特性

抽象类的作用

接口的概念 

接口特性

实现多个接口

接口间的继承

Object类 

抽象类概念

在面向对象的概念中,所有的对象都是通过类来描绘的,但是是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的的类就是抽象类。比如

解析：

1.矩形、三角形、圆形都是图形,因此和Shape类的惯性应该是继承关系
2.虽然图形图Shape中也存在draw的方法,但由于Shape类并不是具体的图形,
因此其内部的draw方法实际是没有办法实现的
3.由于Shape类没有办法描述一个具体的图形,导致其draw()方法
无法县体实现,因此可以将Shape类设计为"抽象类"

在打印图形例子中,我们发现,父类Shape中的draw方法好像并没有什么实际工作,主要的绘制图形都是由Shape的各种子类的draw方法来完成的.像这种没有实际工作的方法,我们可以把它设计成一个抽象方法(abstract method),包含抽象方法的类我们称为抽象类

说明:
1.Animal是动物类,每个动物都有叫的方法,但由于Animal不是个具体的动物,因此其内部bark()方法无法具体实现
2.Dog是狗类,首先狗是动物,因此与Animal是继承关系,其次狗是一种具体的动物,狗叫:汪汪汪,其bark(可以实现
3.Cat是猫类,首先描是动物,因此与Animal是继承关系,其次猫是一种具体的动物,猫叫:喵喵喵,其bark(可以实现
4.因此:Animal可以设计为"抽象类"

抽象类语法和特性

 在Java中,一个类如果被abstract修饰称为抽象类,抽象类中被abstract修饰的方法称为抽象方法,抽象方法不用给出具体的实现体。

//抽象类:被abstract修饰的类
public abstract class Shape {
//抽象方法:被abstract修饰的方法,没有方法体
abstract public void draw();
abstract void calcArea();
//抽象类也是类,也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; //面积
}

注意:抽象类也是类,内部可以包含普通方法和属性,甚至构造造方法

1.抽象类不能直接实例化对象

Shape shape = new Shape();
//编译出错
Error:(30,23) java:Shape是抽象的;无法实例化

抽象方法不能是private的 否则不能被继承

abstract class Shape {
abstract private void draw();
//编译出错
Error:(4,27) java:非法的修饰符组合:abstract和private

3.抽象方法不能被final和static修饰,因为抽象方法要被子类重重写

final的抽象类不能被继承

static的也不可以

public abstract class Shape {
abstract final void methodA();
abstract public static void methodB();
//编译报错:
//Error:(20,25) java:非法的修饰符组合:abstract和final
//Error:(21,33) java:非法的修饰符组合:abstract和static

4.抽象类必须被继承,并且继承后子类要重写父类中的抽象方法,否则子类也是抽象类,必须要使用abstract修饰

//矩形类
public class Rect extends Shape {
private double length;
private double width;

Rect(double length, double width){
this.length = length;
this.width = width;
}
public void draw(){
System.out.println("矩形: length= "+length+" width= "+width);
}
public void calcArea(){
area = length * width;
}
}

public class Circle extends Shape{
private double r;
final private static double PI = 3.14;

public Circle(double r){
this.r = r;
}
public void draw(){
System.out.println("圆: r= "+r);
}
public void calcArea(){
area = PI * r * r;
}

5.抽象类中不一定包含抽象方法,但是有抽象方法的类一定是抽象类
6.抽象类中可以有构造方法,供子类创建对象时,初始化父类的,成员变量

如果一个普通类继承了这个抽象类那么此时这个普通类必须重写这个抽象类当中的抽象方法

抽象类的出现就是为了被继承的!!

实现动态绑定：

这两个叫做匿名对象：匿名对象只能使用一次

抽象类的作用

 抽象类本身不能被实例化,要想使用,只能创建该抽象类的子类。然然后让子类重写抽象类中的抽象方法！！！！
有些同学可能会说了,普通的类也可以被继承呀,普通的方法也可以被重写呀,为啥非得用抽象类和抽象方法呢?
确实如此.但是使用抽象类相当于多了一重编译器的校验.
使用抽象类的场景就如上面的代码,实际工作不应该由父类完成,而应由子类完成.那么此时如果不小心误用成父类了,使用普通类编译器是不会报错的.但是父类是抽象类就会在实例化的时候提示错误,让我们尽早发现问题
很多语法存在的意义都是为了"预防出错",例如我们曾经用过的final也是类似.创建的变量用户不去修改,不就相当于常量嘛?但是加上final能够在不小心误修改的时候,让扁译器及时提醒我们充分利用编译器的校验,在实际开发中是非常有意义的.

接口的概念 

在现实生活中,接口的例子比比皆是,比如:笔记本上的USE3口,电源插座等。

电脑的USB口上,可以插:U盘、鼠标、键盘...所有符合USB协议的设备
电源插座插孔上,可以插:电脑、电视机、电饭煲...所有符合规范的设备
通过上述例子可以看出:接口就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用。
在Java中,接口可以看成是:多个类的公共规范,是一种引用数据类型。

Java不支持多继承
但是我们可以通过接口的形式支持多继承

接口语法规则

 接口的定义格式与定义类的格式基本相同,将class关键字换成interface关键字,就定义了一个接口。

提示:
1.创建接口时,接口的命名一般以大写字母!开头.
2.接口的命名一般使用"形容词"词性的单词.
3.阿里编码规范中约定,接口中的方法和属性不要加任何修饰符号,保持代码的简洁性

publicinterface接口名称{
//抽象方法
public abstract void method1(); //public abstract是固定搭配, 可以不写
public void method2();
abstract void method3();
void method4();
//注意:在接口中上述写法都是抽象方法,跟推荐方式4,代码更简洁
}

接口不能直接使用,必须要有一个"实现类"来"实现"该接口,实现接口中的所有抽象方法。

public class类名称implements接口名称{

注意:子类和父类之间是extends继承关系,类与接口之间是irmplements实现关系。

接口特性

1.接口类型是一种引用类型,但是不能直接new接口的对象，如下图 会报错

public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();

//Error:(10, 19) java: day20210915.USB是抽象的;无法实例化

2.接口中每一个方法都是public的抽象方法,即接口中的方法会被隐式的指定为

public abstract(只能是public abstract,其他修饰符都会报错)

这两者是等价的

public interface USB {
//Error:(4,18)java:此处不允许使用修饰符private
private void openDevice();
void close Device();

3.接口中的方法是不能在接口中实现的,只能由实现接口的类来实现

public interface USB {
void openDevice();
//编译失败:因为接口中的方式默认为抽象方法
// Error:(5, 23) java:接口抽象方法不能带有主体
void closeDevice(){
System.out.println("关闭USB设备");

4.重写接口中方法时,不能使用默认的访问权限

public interface USB {
void openDevice(); //默认是public的
void closeDevice();//默认是public的
}

public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
J
了
//编译报错,重写USB中openDevice方法时,不能使用默认修饰符
//正在尝试分配更低的访问权限;以前为public

5.接口中可以含有变量,但是接口中的变量会被隐式的指定为public static final变量

接口当中的成员变量,默认是public static final修饰的。

上面这两者是等价的

public interface USB {
double brand=3.0;//默认被:final public static修饰
void open Device();
void close Device();
}

public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand);//可以直接通过接口名访问,说明是静态的
//编译报错:Error:(12,12)java:无法为最终变量brand分配值
USB.brand = 2.0;
//说明brand具有final属性

6.接口中不能有静态代码块和构造方法

public interface USB {
//编译失败
public USB(){
}

{}
//编译失败
void open Device();
void close Device();
}

7.接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class
8.如果类没有实现接口中的所有的抽象方法,则类必须设置为抽象类
9.jdk8中:接口中还可以包含default方法。

如果接口当中的方法被default修饰,那么可以有具体的实现

static也是如此：

类和接口之间可以使用关键字implements来实现接口 必须实现接口当中的抽象方法

一个接口对应一个字节码文件

！！！如果一个类不想实现这个接口当中的方法,那么此时这个类就可以被定义为抽象类。但是这个抽象类

如果被继承,那么就得实现所有的没有被实现的方法

请实现笔记本电脑使用USB鼠标、USB键盘的例子
1.USB接口:包含打开设备、关闭设备功能

2.笔记本类:包含开机功能、关机功能、使用USB设备功能

package demo4;

public class computer {
    public void open(){
        System.out.println("开机");
    }
    public void close(){
        System.out.println("关机");
    }
    public void useUsbDevice(USB usb){
        usb.closeDevice();
        if(usb instanceof Mouse){
            Mouse mouse=(Mouse)usb;
            mouse.click();
        }else{
            keyBoard keyBoard=(keyBoard) usb;
            keyBoard.input();
        }
    }
}

3.鼠标类:实现USB接口,并具备点击功能

package demo4;

public class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("点击键盘");
    }
}

4.键盘类:实现USB接口,并具备输入功能 

package demo4;

public class keyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
    public void input(){
        System.out.println("输入数据");
    }
}

测试类：

package demo4;

public class test {
    public static void main(String[] args) {
        computer computer=new computer();
        computer.open();
        computer.useUsbDevice(new keyBoard());
        computer.useUsbDevice(new Mouse());
        computer.close();
    }
}

实现多个接口

 在Java中,类和类之间是单继承的,一个类只能有一个父类,即Java中不支持多继承,但是一个类可以实现多个接口。下面通过类来表示一组动物。

Animal：

public abstract class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void eat();

}

public class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃狗粮");
    }
    public void bark(){
        System.out.println(this.name+"正在汪汪叫..");
    }
}

package demo5;

public class Fish extends Animal{
    public Fish(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃鱼食");
    }
}

实现：

另外我们再提供一组接口,分别表示"会飞的","会跑的","会游泳的"：

具体的对象：

狗是一个动物并且具备游泳和跑的功能
所以,接口的出现 解决了Java不能多继承的问题

测试类：

接口间的继承

在Java中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承。即:用接口可以达到多继承的目的。
接口可以继承一个接口,达到复用的效果.使用extends关键字

接口间的继承相当于把多个接口合并在一起.

interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
//两栖的动物,既能跑,也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {

Object类 

Object是Java默认提供的一个类。Java里面除了Object类,所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。