学懂Java面向对象编程-6

Posted 2023-01-25

一.接口

java中的继承关系是单继承，如果有多个父类的时候，可以考虑使用接口进行实现。接口常常被广泛的使用。

1.了解

1. 使用interface来修饰
2. 接口中可以包含多个方法，且方法跟抽象类的抽象方法一致，可以不实现，子类在实现的时候必须要实现代码逻辑，子类实现接口使用implements关键字

2.接口特性

• 接口中的所有方法都是抽象方法，不能包含方法的实现
• 接口中的所有方法的访问修饰权限都是public，不写不是默认访问权限，而是public
• 接口不能被实例化，不能new
• 接口的子类必须要实现接口中的所有方法，跟抽象类有所不同，抽象类中的抽象方法必须要被实现
• 实现类可以实现多个接口
• 接口中的变量都是静态常量，如果变量没有使用static修饰，也表示静态常量，不使用final，也是静态常量
• 抽象类可以实现接口，并且不实现接口中的方法，而接口只能继承接口，不能实现接口。

3.代码实现USB接口

public interface Usb 
    public void dataTransfer();
    public void play();

public class UPan implements Usb 
    @Override
    public void dataTransfer() 
        System.out.println("upan可以传输数据");
    

public class Mouse implements Usb
    @Override
    public void dataTransfer() 
        System.out.println("鼠标来点击屏幕");
    

public class Test 
    public static void main(String[] args) 
        Mouse mouse = new Mouse();
        mouse.dataTransfer();
        UPan up = new UPan();
        up.dataTransfer();
    

4.使用

1.接口代表一种能力，接口中可以定义多个方法，子类在实现的时候，必须要实现这些方法，将这些方法实现就代表具备方法的能力。

2.关心实现类有何能力，而不关心实现细节

旺财是一只狗------is-a

旺财有一个鼻------has-a

• 闻气味---能力

3.接口是一种约定 

4.规则

• 可以定义一个新接口，用extends去继承一个已有的接口
• 可以定义一个类，用implements去实现一个接口中所有方法。
• 可以定义一个抽象类，用implements去实现一个接口中部分方法。

二.内部类

内部类（当作类中的一个普通成员变量，只不过此成员变量是class的类型）：

一个java文件中可以包含多个class，但是只能有一个public class，如果一个类定义在另一个类的内部，此时可以称之为内部类

1.使用

创建内部类的时候，跟之前的方法不一样，需要在内部类的前面添加外部类来进行修饰

​​InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass();​​

2.特点

1. 内部类可以方便的访问外部类的私有属性
2. 外部类不能访问内部类的私有属性,但是如果创建了内部类的对象，此时可以在外部类中访问私有属性
3. 内部类中不能定义静态属性
4. 当内部类和外部类具有相同的私有属性的时候，在内部类中访问的时候，可以直接访问内部类的属性

public class Outer 
    private String name = "zhangsan";
    class Inner
        private String name = "lisi";
        public void show()
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(Outer.this.name);
        
    
    public static void main(String[] args) 
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    

5. 如果需要访问外部类的属性，那么需要添加  外部类类名.this.属性。

public class InnerClassDemo 
    private int id;
    private String name;
    public int getId() 
        return id;
    
    public void setId(int id) 
        this.id = id;
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    
    public void show()
        System.out.println("show");
//      System.out.println(age);
        InnerClass inner = new InnerClass();
        System.out.println(inner.age);//创建了内部类的对象，此时可以在外部类中访问私有属性
    
    class InnerClass
        private int age;
//      static String name = "zhangsan";
        public void test()
            System.out.println("test");
            System.out.println(id);
            System.out.println(name);
        
        class InnerInner
            private int id;
            public void print()
                System.out.println("print");
            
        
    
    public static void main(String[] args) 
        InnerClass innerClass = new InnerClassDemo().new InnerClass();
    

public class TestInnerClass 
    public static void main(String[] args) 
//      System.gc();
        InnerClassDemo innerClassDemo = new InnerClassDemo();
        innerClassDemo.show();
        System.out.println(innerClassDemo.getName());
        InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass();
        inner.test();
//      System.out.println(inner.age);
        InnerClassDemo.InnerClass.InnerInner innerInner = new InnerClassDemo().new InnerClass().new InnerInner();
    

3.分类

1. 匿名内部类：当定义了一个类，实现了某个接口的时候，在使用过程中只需要使用一次，没有其他用途

1. 其实考虑到代码编写的简洁，可以考虑不创建具体的类，而采用new interface()添加未实现的方法就叫做匿名内部类

public class NoNameInnerClassDemo 
    public static void main(String[] args) 
        System.out.println("有一万行代码");
        new Thread(new Runnable() 
            @Override
            public void run() 
            //看似NEW了一个接口，实则是类里的实现方法
        );
        System.out.println("有一万行代码");
    

class Runner implements Runnable
    @Override
    public void run() 
    

2. 静态内部类：在内部类中可以定义静态内部类，使用static关键字进行修饰，使用规则

1. 外部类.内部类 类的引用名称 = new 外部类.内部类（）

public class StaticClass 
    private int id;
    public void test()
        System.out.println("test");
    
    static class InnerClass
        private String name;
        public void show()
            System.out.println("show");
        
    
    public static void main(String[] args) 
        InnerClass innerClass = new StaticClass.InnerClass();//静态类通过类名调用，无()
//      InnerClass innerClass = new StaticClass().new InnerClass();//内部类看作外部类的一个对象，有()
    

3. 方法内部类：在外部类的方法中也可以定义类，此时叫做方法内部类

1. 使用的时候需要注意，只能在方法中创建对象，因为此class的作用域就是当前方法
2. 方法内部类不能在外部类的方法以外的地方使用，所以方法内部类丌能使用访问控制符和static修饰符

public class MethodInnerClass 
    public void show(int number)
        System.out.println("show");
        class InnerClass
            private String name;
            public void test(int a)
                System.out.println("test");
                System.out.println(a);
                System.out.println(number);
            
        
        new InnerClass().test(888);
    
    public static void main(String[] args) 
        MethodInnerClass  methodInnerClass = new MethodInnerClass();
        methodInnerClass.show(666);