Java学习 四 核心技术——抽象类，接口

抽象类
抽象类是一种特殊的类：

1. 抽象类与抽象方法都必须使用abstract关键字修饰
2. 抽象类都不能直接实例化，也不能使用new关键字去产生对象
3. 抽象方法只需要说明，而不需要实现
4. 含有抽象方法的类必定是抽象类，抽象类的子类必须覆写所有方法才能不是抽象类；

//抽象类
abstract class Animal{
    String name;
    String sex;
    int age;
    public abstract void setName(String name);
    public abstract void setSex(String sex);
    public abstract void setAge(int age);
    public abstract String getName();
    public abstract String getSex();
    public abstract int getAge();
}

使用抽象类进行复制

class Dog extends Animal{

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public String getSex() {
        return this.sex;
    }

    @Override
    public int getAge() {
        return this.age;
    }
}

注意：抽象类中也可以出现一般方法；
抽象类的作用在于增加子类拓展性；

接口
接口也是一种特殊的类：

1. 接口内的数据成员必须初始化，且是常量
2. 接口内的方法必须都是abstract，不可以和抽象类一样有一般方法；

接口的出现是为了Java的多继承机制出现的。

interface test_interface{
    //数据成员必须是复制的常量，前面的“final”可以省略
    final String name = "mini";
    final String sex = "woman";
    final int age = 23;
    //方法必须是抽象方法，不能有一般方法；
    abstract void show();
}
}

使用接口：

//接口的使用与类的继承关键词不一样：“implement”；
class test implements test_interface{

    @Override
    public void show() {
        System.out.println(this.name+"\t"+this.sex+"\t"+this.age);
    }
}

接口的实际使用方法：
一：一个类只能继承一个父类，但它可以继承多个接口

interface A{
    String name ="A";
    abstract void show_A();
}
interface B{
    String name = "B";
    abstract void show_B();
}
interface C{
    String name ="C";
    abstract void show_C();
}


class show_A_B_C implements A,B,C{

    @Override
    public void show_A() {
        System.out.println("A");
    }

    @Override
    public void show_B() {
        System.out.println("B");
    }

    @Override
    public void show_C() {
        System.out.println("C");
    }
}

二：一个接口可以继承多个接口，例如“C”

interface A{
    String name ="A";
    abstract void show_A();
}
interface B{
    String name = "B";
    abstract void show_B();
}
interface C extends A,B{
    String name ="C";
    abstract void show_C();
}


class show_A_B_C implements C{

    @Override
    public void show_A() {
        System.out.println("A");
    }

    @Override
    public void show_B() {
        System.out.println("B");
    }

    @Override
    public void show_C() {
        System.out.println("C");
    }
}

测试：设计一个限制子类访问的抽象类实例，要求在控制台输出下列结果：
干部---->姓名：李乐乐,年龄：李乐乐,性别：男
工人---->姓名：王小六,年龄：王小六,性别：男

package com.gao;

public class Test_10 {
    public static void main(String[] args) {
        Worker worker_1 = new Worker("干部","李乐乐",20,"男");
        Worker worker_2 = new Worker("工人","王小六",30,"男");
        worker_1.show_date();
        worker_2.show_date();
    }
}

class Worker extends People{
    public Worker(String job,String name,int age,String sex){
        this.setAge(age);
        this.setName(name);
        this.setSex(sex);
        this.setJob(job);
    }
    @Override
    void show_date() {
        System.out.println(this.getJob()+"---->姓名："+this.getName()+",年龄："+this.getAge()+",性别："+this.getSex());
    }
}

abstract class People{
    private String name;
    private String job;
    private String sex;
    private int age;
    abstract void show_date();

    public void setAge(int age) {
        this.age = age;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public String getJob() {
        return job;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }
}