1. Johngo学长首页
  2. 技术点详细复盘专题
  3. 其他编程语言
  4. Java

Java面向对象（八）

• Java • 阅读 86 
public class PersonTest {
    public static void main(String[] args) {

        //非匿名的类非匿名的对象
        Worker worker = new Worker();
        method1(worker);
        //非匿名的类匿名的对象
        method1(new Worker());
        //创建了一匿名子类的非匿名对象：p
        Person p = new Person(){
            @Override
            public void eat() {
                System.out.println("吃东西");
            }
            @Override
            public void breath() {
                System.out.println("好好呼吸");
            }
        };
        method1(p);
        //创建匿名子类的匿名对象
        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();
    }
}
class Worker extends Person{
    @Override
    public void eat() {
    }
    @Override
    public void breath() {
    }
}


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

interface i {
    // 全局变量
    public static final int MAX_NUM = 100;  //完整写法
    int MIN_NUM = 1; //省略了public static final

    // 抽象方法
    public abstract void show();
    //省略了public abstract
    void change();

}

class I implements i {

    @Override
    public void show() {
        System.out.println("调用i接口的show方法");
    }

    @Override
    public void change() {
        System.out.println("调用i接口的change方法");
    }

}
// 实现类没有覆盖接口中所有的抽象方法
abstract class I2 implements i{

    @Override
    public void show() {

    }

}

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(i.MAX_NUM);
        System.out.println(i.MIN_NUM);
//      i.MIN_NUM = 2;

        I i2 = new I();
        i2.show();
    }
}

class Bullet extends Object implements CC,DD{

    @Override
    public void method1() {
        // TODO Auto-generated method stub

    }

    @Override
    public void method2() {
        // TODO Auto-generated method stub

    }

interface AA{
    void method1();
}
interface BB{
    void method2();
}
interface CC extends AA,BB{
}
interface DD{
}

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

        Computer com = new Computer();

        Flash flash = new Flash();
        com.transferData(flash);

    }
}

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 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 StaticProxyTest {

    public static void main(String[] args) {
        Star 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("经纪人收钱");
    }
}
  • 静态代理（静态定义代理类）
  • 动态代理（动态生成代理类）：JDK自带的动态代理，需要反射等知识

example one：

interface A {
    int x = 0;
}

class B {
    int x = 1;
}

class C extends B implements A {
    public void pX() {
        // The field x is ambiguous（编译不通过。因为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();
    }
}

example two：

interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable,
    Bounceable {
    Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;
    }
    public void play() {
        ball = new Ball("Football");    // 编译报错，在接口中已经定义了ball对象，所以该对象为 public static final，此处违反 final 不能重新赋值
        System.out.println(ball.getName());
    }
}

例子：

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：上海");
    }

}

public class SuperClass {

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

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();
    }
}

NO. 区别点 抽象类 接口 1 定义 包含抽象方法的类 主要是抽象方法和全局常量的集合 2 组成 构造方法、抽象方法、普通方法、 常量、变量 常量、抽象方法、(jdk8.0:默认方法、静态方法) 3 使用 子类继承抽象类(extends) 子类实现接口(implements) 4 关系 抽象类可以实现多个接口 接口不能继承抽象类，但允许继承多个接口 5 常见设计模式 模板方法 简单工厂、工厂方法、代理模式 6 对象 都通过对象的多态性产生实例化对象 7 局限 抽象类有单继承的局限 接口没有此局限 8 实际 作为一个模板 是作为一个标准或是表示一种能力 9 选择 如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局

  • 在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类， 要么实现接口。

Original: https://www.cnblogs.com/xiaozhao01/p/16519007.html
Author: 小钊丶
Title: Java面向对象（八）

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/593505/

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
0

【自取】最近整理的，有需要可以领取学习：



Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言 刷题答案下载！

大家都在看

亲爱的 Coder【最近整理，可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球