Java学习日记-16

芝士顶针

已于 2022-11-08 21:26:28 修改

阅读量265

点赞数 3

文章标签： java jvm 开发语言

于 2022-11-08 21:17:29 首次发布

本文链接：https://blog.youkuaiyun.com/a1245673676/article/details/127758856

版权

一、接口引入：

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方
法。但是，Java不支持多重继承，有了接口，就可以得到多重继承的效果。
另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又
没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打
印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都
支持USB连接。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要。则
必须能。”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"
的关系。
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都
要遵守。

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 A extends B implements C,D

7. 接口与接口之间可以继承，且可以多继承

8. 接口的使用，体验多态性

9. 接口可以看作一种规范

验证代码：

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(FlyAble.Max_Speed);
    }

}

interface Attack{
    void attack();
}

interface FlyAble{
    //全局常量
    public  static  final int  Max_Speed = 7900;
    int Min_Speed = 1; //省略了public static final

    //抽象方法
    public abstract void fly();
    void stop();//省略了public abstract
}

  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() {
        System.out.println("风筝飞！");

    }
    //此时还有一个抽象方法没有被重写，则在类前面加上abstract标明还是一个抽象方法
}

class Bullet implements FlyAble,Attack{
    @Override
    public void attack() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }
}

//接口多继承
interface  AA{

}
interface  BB{

}
interface cc extends AA,BB{

}

二、代理模式：

public class ProxyTest {
    public static void main(String[] args) {
        Server server = new Server();
        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 network;

    public ProxyServer(Network network){
        this.network = network;
    }

    @Override
    public void browse() {
        check();
        this.network.browse();
    }
    public void check(){
        System.out.println("上网之前的检查工作");
    }
}

三、JDK8接口的新特性：

接口1：

public interface JDK8Interface {
    public static void method1(){
        System.out.println("hello");
    }
    default void method2(){
        System.out.println("hello old");
    }
    default void method3(){
        System.out.println("interface:hello ");
    }

}

接口2：

public interface JDK8Interface1 {
    default  void method3(){
        System.out.println("interface1：hello");
    }
}

子类测试新特性：

public class SubClassTest {
    public static void main(String[] args) {
        //1.接口定义的静态方法，只能通过接口来调用
        JDK8Interface.method1();

        SubClass s1 = new SubClass();

        //2.接口定义的默认方法，可以通过实现类的对象来调用
        //  如果实现类重写了接口中的默认方法，则实现类的对象调用的是重写后的方法
        s1.method2();

        //3.如果子类或实现类继承的父类和实现的接口中声明了同名同参的方法，
        //  那么在子类在没有重写此方法的情况下，默认调用的是父类中的同名同参的方法 --》类优先原则
        //4.如果一个实现类的实现了两个接口，两个接口中都声明了同名同参的方法，且实现类没有重写，那么则会报错 -->接口冲突
        s1.method3();

    }

}

class SubClass extends SuperClass implements JDK8Interface, JDK8Interface1{
    @Override
    public void method2() {
        System.out.println("hello1 new");
    }

    @Override
    public void method3() {
        System.out.println("override  method3");
    }
    // 5.如何在子类(或实现类)中调用父类、接口中被重写的方法
    public void myMehtod(){
        //调用自己重写的方法
        method3();

        //调用父类的method3方法
        super.method3();

        //调用接口默认的方法
        JDK8Interface.super.method2();
        JDK8Interface.super.method3();
    }
}

父类：

public class SuperClass {
    public void method3(){
        System.out.println("superClass:hello");
    }

}

四、内部类：

1.java中允许讲一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类

2.内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
3.成员内部类：
一方面，作为外部类的成员
>调用外部类的结构
>被static修饰
>可以被四种不同权限修饰符修饰

另一方面作为一个类：
>可以定义属性、方法、构造器等
>可以被final修饰就不可以被继承，不使用final就可以被继承

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 bird1 = p.new Bird();
        bird1.birdEat();
        bird1.shows("小明");


    }


}

class Person{
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    //静态成员内部类
    static class Dog{
        public void show(){
            System.out.println("我是一只狗");
        }
    }
    //非静态成员内部类
    class Bird{
        String name;
        {
            String name;
            System.out.println("我是一只鸟");
        }
        public void birdEat(){
            Person.this.eat();//调用外部类的方法;
        }
        public void shows(String name){
            //如何调用外部类结构重名时，没重名不用加前缀
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(Person.this.name);
            System.out.println(age);
        }
    }
    public Person(){
        //局部内部类
        class CC{

        }
    }
}

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

        }


    }
    //返回了一个实现了Compare接口的类的对象
    public Comparable getComparable(){
        //创建一个实现了Comparable接口的类：局部内部类
//        class MyComparable implements Comparable{
//            @Override
//            public int compareTo(Object o){
//                return 0;
//            }
//        }
//        return new MyComparable();

        //方式2：创建匿名实现类的匿名对象
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };

    }
}