Java面向对象-抽象类与接口

一、final关键字的使用

• final关键字在java中被称为完结器，表示最终的意思。
• final能声明类、方法、属性：

• 使用final声明的类不能被继承。
• 使用final声明的方法不能被重写。
• 使用final声明的变量变成常量，常量是不可以被修改的。
  final String NAME = "Hello"; //name大写

二、抽象类

1、概述

• 抽象类概念：包含一个抽象方法的类就是抽象类。
• 抽象方法：声明而未被实现的方法，抽象方法必须使用abstract关键字声明。
• 抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中德所有抽象方法。
• 定义格式：
  abstract class className{ 属性 方法 抽象方法 }
• 抽象类不能直接实例化，要通过其子类进行实例化。

代码
abstract class Abs{
    private int age;
    
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void tell() {
        
    }
    //抽象方法
    public abstract void say();
    public abstract void print();
}
class AbsDemo extends Abs{
    public void say() {
        System.out.println(getAge());
    }
    public void print() {
        
    }
}
public class Demo20 {
    public static void main(String[] args) {
        AbsDemo a = new AbsDemo();
        a.setAge(20);
        a.say();
        a.print();
        a.setAge(20);
    }
}
结果：
20

2、应用

代码
abstract class PersonN{
    private int age;
    private String name;
    
    public PersonN(int age,String name){
        this.age = age;
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    //抽象方法
    public abstract void want();
}
class Stu extends PersonN{

    private int score;
    
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }

    public Stu(int age, String name,int score) {
        super(age, name);
        // TODO Auto-generated constructor stub
        this.score = score;
    }

    @Override
    public void want() {
        // TODO Auto-generated method stub
        System.out.println("姓名："+getName()+"  年龄："+getAge()+"  成绩："+getScore());
    }
}

class Work extends PersonN{
    
    private int money;
    
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }

    public Work(int age, String name,int money) {
        super(age, name);
        // TODO Auto-generated constructor stub
        this.money = money;
    }

    @Override
    public void want() {
        // TODO Auto-generated method stub
        System.out.println("姓名："+getName()+"  年龄："+getAge()+"  工资："+getMoney());
    }
}
public class Demo25 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Stu tu = new Stu(10, "小明", 100);
        tu.want();
        Work w = new Work(35, "大明", 1000);
        w.want();
    }

}
结果：
姓名：小明  年龄：10  成绩：100
姓名：大明  年龄：35  工资：1000

三、接口

1、实现

• 接口是Java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
• 接口的格式：
  interface interfaceName{ 全局常量 抽象方法 }
• 接口的实现也必须通过子类，使用关键字implements，而且接口是可以多实现的。
• 一个子类可以同时继承抽象类和实现接口。
• 一个接口不能继承一个抽象类，但是却可以通过extends关键字同时继承多个接口，实现接口的多继承。

代码
interface Inter1{
    public static final int AGE = 100;//全局常量
    public abstract void tell();    
}
interface Inter2{
    public abstract void say();
}

abstract class Abs1{
    public abstract void print();
}

class Ai extends Abs1 implements Inter1,Inter2{
    public void tell() {
        
    }
    public void say() {
        
    }
    public void print() {
        
    }
}
interface Inter3 extends Inter1,Inter2{
    
}
public class Demo21 {
    public static void main(String[] args) {
        Ai a = new Ai();
        a.tell();
        System.out.println(Inter1.AGE);
        a.say();
        a.print();
    }
}

2、使用

代码
interface USB{
    //抽象方法
    void start();
    void stop();
}
class C{
    public static void work(USB u) {
        u.start();
        System.out.println("工作中");
        u.stop();
    
    }
}
class USBDisk implements USB{

    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("U盘停止工作");
    }
    
}
class Printer implements USB{

    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("打印机停止工作");
    }
    
}
public class Demo26 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        C.work(new USBDisk());
        C.work(new Printer());
    }

}
结果：
U盘开始工作
工作中
U盘停止工作
打印机开始工作
工作中
打印机停止工作