面对对象3 抽象类 接口 final关键字

面对对象3 抽象类 接口 final关键字

抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。
用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。抽象类不一定有抽象方法

public abstract class Animals {//不能用抽象类创建对象
    
    String name;

    public abstract void eat();//抽象方法没有方法体
    public abstract void name();

    public Animals(){//抽象类中可以有构造方法

    }
}

特点:
抽象类不能被实例化，但可以有构造函数,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
抽象类只能用作基类(父类)，表示的是一种继承关系。

他就是用来被继承的,一个类继承抽象类,要么将子类定义为抽象类类,要么使用重写.重写所有抽象类中的方法.

抽象方法

抽象方法是一种特殊的方法:只有声明,没有具体体现,也就是没有方法体.

抽象方法必须用abstract关键字进行修饰

public abstract void eat();//抽象方法没有方法体
    public abstract void name();

使用关键字abstract定义抽象类,一般语法

[访问权限] abstract class 类名 {
成员列表
}

public abstract class Animals {//不能用抽象类创建对象
public abstract void eat();
}

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

接口

生活中常见的接口有:usb充电器,u盘等等

可以使用Java接口来实现

USB本身没有实现任何功能

USB接口规定了数据传输的要求

USB接口可以被多种USB设备实现

编写USB接口---->根据需求设计方法

实现USB接口----->实现所有方法

使用USB接口----->用多态的方式使用

public interface  Animal {
    /*
    interface关键字修饰的是接口
     */
    public static final int num=0;
    /*
    变量默认为 public static final 修饰
     */
    public abstract void eat();
    void sleep();
    /*
    方法默认为抽象类型的方法
    public abstract void eat();
     */

}

使用interface关键字修饰的是接口.

接口中变量默认被public static final修饰

接口中方法默认为抽象类型的方法public abstract void/返回值类型 方法名(){}

接口特性:

接口不可以被实例化

实现类必须重写接口的所有方法,否则报错

实现类可以实现多个接口

接口中的变量都是静态常量

用implements关键字实现接口

public class Dog implements Animal{

面向接口编程

关心实现类有什么功能,而不管细节方面

面向接口的约定而不考虑接口的具体实现

接口存在的意义

java中一个类只能有一个父类,所以用接口可以实现多继承的逻辑

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n] {
// 声明常量
// 抽象方法
}

public interface  Animal {
    
    public static final int num=0;//声明常量
    
    public abstract void eat();//抽象方法
    void sleep();
}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

public class Dog implements Animal1,Animasl2{}

结合继承：
[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

public class Dog extends Animal implements Animal{}

接口的特性

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，默认为public abstract 。
接口中声明的属性默认为 public static final 的；
接口不是被类继承了，而是要被类实现。
接口不能实例化对象（无构造方法），但可以声明对象的引用。（多态性）
多个类可以实现同一个接口。
一个类可以实现多个接口，但只能继承一个类。
与继承关系类似，接口与实现类之间存在多态性。
一个接口能继承其它多个接口。
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

final关键字

先把整体代码贴上来,再逐一介绍

/*
final用于声明属性,方法,类
被final修饰的类不能被继承,并且不能被定义为抽象类或是接口
//public final class FinalDemo{}
 */
public  class FinalDemo {
    /*
    定义就必须直接赋值或者在构造方法中进行赋值,并且不能再修改
     */
    final int num = 10;//final修饰的变量变为常量 值不能改变
    //直接初始化变量        建议用static修饰 在内存中就只有一份了
    int count;//在创建的每个对象中包含一个常量 必须在构造方法中赋值
    /*
    在声明时没有赋值,则必须在构造方法中逐一赋值
     */

    public FinalDemo(){
        //默认无参的构造方法
    }
    public FinalDemo(int a){
        count=a;
        System.out.println(count);
    }
    public void test(final int a){
        System.out.println(a);
    }
    public final void eat(){//被final修饰的方法不能被子类重写
        System.out.println("吃");

    }

    public static void main(String[] args) {
        FinalDemo f1 = new FinalDemo(10);
        FinalDemo f2 = new FinalDemo(5);
    }
}

final 用于声明属性，方法和类,被final修饰的类不能被继承,并且不能被定义为抽象类或者是接口

public final class FinalDemo{}

属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。

如果在声明时没有赋值,则必须在构造方法中逐一赋值

final int num = 10;//final修饰的变量变为常量 值不能改变
 int count;//在创建的每个对象中包含一个常量 必须在构造方法中赋值

int count在声明时没有赋值,则必须要在构造方法中赋值

public FinalDemo(int a){
        count=a;
        System.out.println(count);
    }

public static void main(String[] args) {
        FinalDemo f1 = new FinalDemo(10);
    }

方法:子类里不可被覆盖。

public final void eat(){//被final修饰的方法不能被子类重写
        System.out.println("吃");
    }

类:不能被定义为抽象类或是接口,不可被继承。