Java基础-抽象类与接口

最新推荐文章于 2022-12-31 16:40:01 发布

Achilles159

最新推荐文章于 2022-12-31 16:40:01 发布

阅读量188

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_32639315/article/details/109297953

版权

Java 专栏收录该内容

49 篇文章 1 订阅

订阅专栏

1. 抽象类

1.1 abstract关键字的使用

1.abstract:抽象的
2.abstract可以用来修饰的结构：类、方法
3. abstract修饰类：抽象类
此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4. abstract修饰方法：抽象方法
抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

public class AbstractTest {
    public static void main(String[] args) {

        // 一旦Person类抽象了，就不可实例化
        // Person p1 = new Person();
        // p1.eat();

    }
}

abstract class Creature {
    public abstract void breath();
}

abstract class Person extends Creature {
    String name;
    int age;

    public Person() {

    }

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

    // 不是抽象方法：
    // public void eat(){
    //
    // }
    // 抽象方法
    public abstract void eat();

    public void walk() {
        System.out.println("人走路");
    }

}

class Student extends Person {

    public Student(String name, int age) {
        super(name, age);
    }

    public Student() {
    }

    public void eat() {
        System.out.println("学生多吃有营养的食物");
    }

    @Override
    public void breath() {
        System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
    }
}

abstract使用上的注意点：
1.abstract不能用来修饰：属性、构造器等结构
2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

1.2 抽象类的匿名子类

public class PersonTest {

    public static void main(String[] args) {

        method(new Student());// 匿名对象

        Worker worker = new Worker();
        method1(worker);// 非匿名的类非匿名的对象

        method1(new Worker());// 非匿名的类匿名的对象

        System.out.println("********************");

        // 创建了一匿名子类的对象：p
        Person p = new Person() {

            @Override
            public void eat() {
                System.out.println("吃东西");
            }

            @Override
            public void breath() {
                System.out.println("好好呼吸");
            }

        };

        method1(p);
        System.out.println("********************");
        // 创建匿名子类的匿名对象
        method1(new Person() {
            @Override
            public void eat() {
                System.out.println("吃好吃东西");
            }

            @Override
            public void breath() {
                System.out.println("好好呼吸新鲜空气");
            }
        });
    }

    public static void method1(Person p) {
        p.eat();
        p.breath();
    }

    public static void method(Student s) {

    }
}

class Worker extends Person {

    @Override
    public void eat() {
    }

    @Override
    public void breath() {
    }

}

1.3 抽象类的应用

1.3.1 模板方法的设计模式1

public class TemplateTest {
    public static void main(String[] args) {

        SubTemplate t = new SubTemplate();

        t.spendTime();
    }
}

abstract class Template {

    // 计算某段代码执行所需要花费的时间
    public void spendTime() {

        long start = System.currentTimeMillis();

        this.code();// 不确定的部分、易变的部分

        long end = System.currentTimeMillis();

        System.out.println("花费的时间为：" + (end - start));

    }

    public abstract void code();

}

class SubTemplate extends Template {

    @Override
    public void code() {

        for (int i = 2; i <= 1000; i++) {
            boolean isFlag = true;
            for (int j = 2; j <= Math.sqrt(i); j++) {

                if (i % j == 0) {
                    isFlag = false;
                    break;
                }
            }
            if (isFlag) {
                System.out.println(i);
            }
        }

    }

}

1.3.2 模板方法的设计模式2

public class TemplateMethodTest {

    public static void main(String[] args) {
        BankTemplateMethod btm = new DrawMoney();
        btm.process();

        BankTemplateMethod btm2 = new ManageMoney();
        btm2.process();
    }
}

abstract class BankTemplateMethod {
    // 具体方法
    public void takeNumber() {
        System.out.println("取号排队");
    }

    public abstract void transact(); // 办理具体的业务 //钩子方法

    public void evaluate() {
        System.out.println("反馈评分");
    }

    // 模板方法，把基本操作组合到一起，子类一般不能重写
    public final void process() {
        this.takeNumber();

        this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

        this.evaluate();
    }
}

class DrawMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要取款！！！");
    }
}

class ManageMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要理财！我这里有2000万美元!!");
    }
}

2. 接口

2.1 接口的使用

1.接口使用interface来定义
2.Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
   3.1 JDK7及以前：只能定义全局常量和抽象方法
       >全局常量：public static final的.但是书写时，可以省略不写
       >抽象方法：public abstract的
   3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
4. 接口中不能定义构造器的！意味着接口不可以实例化
5. Java开发中，接口通过让类去实现(implements)的方式来使用.
   如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6. Java类可以实现多个接口 --->弥补了Java单继承性的局限性
   格式：class AA extends BB implements CC,DD,EE
7. 接口与接口之间可以继承，而且可以多继承
8. 接口的具体使用，体现多态性
9. 接口，实际上可以看做是一种规范
面试题：抽象类与接口有哪些异同？

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);
        // Flyable.MIN_SPEED = 2;

        Plane plane = new Plane();
        plane.fly();
    }
}

interface Flyable {

    // 全局常量
    public static final int MAX_SPEED = 7900;// 第一宇宙速度
    int MIN_SPEED = 1;// 省略了public static final

    // 抽象方法
    public abstract void fly();

    // 省略了public abstract
    void stop();

    // Interfaces cannot have constructors
    // public Flyable(){
    //
    // }
}

interface Attackable {

    void attack();

}

class Plane implements Flyable {

    @Override
    public void fly() {
        System.out.println("通过引擎起飞");
    }

    @Override
    public void stop() {
        System.out.println("驾驶员减速停止");
    }

}

abstract class Kite implements Flyable {

    @Override
    public void fly() {

    }

}

class Bullet extends Object implements Flyable, Attackable, CC {

    @Override
    public void attack() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

}
// ************************************

interface AA {
    void method1();
}

interface BB {

    void method2();
}

interface CC extends AA, BB {

}

/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 * 
 */
public class USBTest {
    public static void main(String[] args) {

        Computer com = new Computer();
        // 1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);

        // 2. 创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());

        // 3. 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB() {

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }

        };
        com.transferData(phone);

        // 4. 创建了接口的匿名实现类的匿名对象

        com.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });
    }
}

class Computer {

    public void transferData(USB usb) {// USB usb = new Flash();
        usb.start();

        System.out.println("具体传输数据的细节");

        usb.stop();
    }

}

interface USB {
    // 常量：定义了长、宽、最大最小的传输速度等

    void start();

    void stop();

}

class Flash implements USB {

    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }

}

class Printer implements USB {
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }

}

/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
    public static void main(String[] args) {
        Server server = new Server();
        // server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();

    }
}

interface NetWork {
    public void browse();
}

// 被代理类
class Server implements NetWork {

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }
}

// 代理类
class ProxyServer implements NetWork {

    private NetWork work;

    public ProxyServer(NetWork work) {
        this.work = work;
    }

    public void check() {
        System.out.println("联网之前的检查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }

}

public class StaticProxyTest {

    public static void main(String[] args) {
        Proxy s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }
}

interface Star {
    void confer();// 面谈

    void signContract();// 签合同

    void bookTicket();// 订票

    void sing();// 唱歌

    void collectMoney();// 收钱
}

// 被代理类
class RealStar implements Star {

    public void confer() {
    }

    public void signContract() {
    }

    public void bookTicket() {
    }

    public void sing() {
        System.out.println("明星：歌唱~~~");
    }

    public void collectMoney() {
    }
}

// 代理类
class Proxy implements Star {
    private Star real;

    public Proxy(Star real) {
        this.real = real;
    }

    public void confer() {
        System.out.println("经纪人面谈");
    }

    public void signContract() {
        System.out.println("经纪人签合同");
    }

    public void bookTicket() {
        System.out.println("经纪人订票");
    }

    public void sing() {
        real.sing();
    }

    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

interface A {
    int x = 0;
}

class B {
    int x = 1;
}

class C extends B implements A {
    public void pX() {
        // 编译不通过。因为x是不明确的
        // System.out.println(x);
        System.out.println(super.x);// 1
        System.out.println(A.x);// 0

    }

    public static void main(String[] args) {
        new C().pX();
    }
}

2.2 Java8中接口新特性

JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

public interface CompareA {

    // 静态方法
    public static void method1() {
        System.out.println("CompareA:北京");
    }

    // 默认方法
    public default void method2() {
        System.out.println("CompareA：上海");
    }

    default void method3() {
        System.out.println("CompareA：上海");
    }
}

public interface CompareB {

    default void method3() {
        System.out.println("CompareB：上海");
    }

}

interface Filial {// 孝顺的
    default void help() {
        System.out.println("老妈，我来救你了");
    }
}

interface Spoony {// 痴情的
    default void help() {
        System.out.println("媳妇，别怕，我来了");
    }
}

class Father {
    public void help() {
        System.out.println("儿子，就我媳妇！");
    }
}

class Man extends Father implements Filial, Spoony {

    @Override
    public void help() {
        System.out.println("我该就谁呢？");
        Filial.super.help();
        Spoony.super.help();
    }
}

public class SubClassTest {

    public static void main(String[] args) {
        SubClass s = new SubClass();

        // s.method1();
        // SubClass.method1();
        // 知识点1：接口中定义的静态方法，只能通过接口来调用。
        CompareA.method1();
        // 知识点2：通过实现类的对象，可以调用接口中的默认方法。
        // 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
        s.method2();
        // 知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
        // 那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
        // 知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
        // 那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
        // 这就需要我们必须在实现类中重写此方法
        s.method3();

    }

}

class SubClass extends SuperClass implements CompareA, CompareB {

    public void method2() {
        System.out.println("SubClass：上海");
    }

    public void method3() {
        System.out.println("SubClass：深圳");
    }

    // 知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
    public void myMethod() {
        method3();// 调用自己定义的重写的方法
        super.method3();// 调用的是父类中声明的
        // 调用接口中的默认方法
        CompareA.super.method3();
        CompareB.super.method3();
    }
}

public class SuperClass {

    public void method3() {
        System.out.println("SuperClass:北京");
    }

}

3. 内部类

类的内部成员之五：内部类
1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2.内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
3.成员内部类：
   一方面，作为外部类的成员：
   >调用外部类的结构
   >可以被static修饰
   >可以被4种不同的权限修饰

   另一方面，作为一个类：
   > 类内可以定义属性、方法、构造器等
   > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
   > 可以被abstract修饰
4.关注如下的3个问题
   4.1 如何实例化成员内部类的对象
   4.2 如何在成员内部类中区分调用外部类的结构
   4.3 开发中局部内部类的使用见《InnerClassTest1.java》

public class InnerClassTest {
    public static void main(String[] args) {

        // 创建Dog实例(静态的成员内部类):
        Person.Dog dog = new Person.Dog();
        dog.show();
        // 创建Bird实例(非静态的成员内部类):
        // Person.Bird bird = new Person.Bird();//错误的
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();

        System.out.println();

        bird.display("黄鹂");
    }
}

class Person {

    String name = "小明";
    int age;

    public void eat() {
        System.out.println("人：吃饭");
    }

    // 静态成员内部类
    static class Dog {
        String name;
        int age;

        public void show() {
            System.out.println("卡拉是条狗");
            // eat();
        }

    }

    // 非静态成员内部类
    class Bird {
        String name = "杜鹃";

        public Bird() {

        }

        public void sing() {
            System.out.println("我是一只小小鸟");
            Person.this.eat();// 调用外部类的非静态属性
            eat();
            System.out.println(age);
        }

        public void display(String name) {
            System.out.println(name);// 方法的形参
            System.out.println(this.name);// 内部类的属性
            System.out.println(Person.this.name);// 外部类的属性
        }
    }

    public void method() {
        // 局部内部类
        class AA {

        }
    }

    {
        // 局部内部类
        class BB {

        }
    }

    public Person() {
        // 局部内部类
        class CC {

        }
    }
}

public class InnerClassTest1 {

    // 开发中很少见
    public void method() {
        // 局部内部类
        class AA {

        }
    }

    // 返回一个实现了Comparable接口的类的对象
    public Comparable getComparable() {

        // 创建一个实现了Comparable接口的类:局部内部类
        // 方式一：
        // class MyComparable implements Comparable{
        //
        // @Override
        // public int compareTo(Object o) {
        // return 0;
        // }
        //
        // }
        //
        // return new MyComparable();

        // 方式二：
        return new Comparable() {

            @Override
            public int compareTo(Object o) {
                return 0;
            }

        };

    }

}

Achilles159

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础-抽象类与接口

1. 抽象类1.1 abstract关键字的使用/** 1.abstract:抽象的* 2.abstract可以用来修饰的结构：类、方法** 3. abstract修饰类：抽象类* > 此类不能实例化* > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）* > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作*** 4. abstract修饰方法：抽象方法...
复制链接

扫一扫

专栏目录