Java中接口抽象类与内部类学习

Posted 2020-10-10 PrivateO2

Java中接口、抽象类与内部类学习

接口与内部类为我们提供了一种将接口与实现分离的更加结构化的方法。

抽象类和抽象方法

抽象方法：仅有声明而没有方法体。
抽象类：包含一个或多个抽象方法的类，该类就必须限定为抽象的（否则会报错）。

abstract void f() {  //抽象方法
}

抽象类的特点：

1. 抽象类中的方法并不需要所有的方法都是抽象的，只需部分的方法是抽象的即可。
2. 如果一个新类从一个抽象类继承，并想创建该新类的对象，name就必须为基类中所有的抽象方法提供方法定义。否则导出类也是抽象类，并要用abstract修饰该类。
3. 抽象类并不能被实例化。
4. 抽象类中的抽象方法不能有方法体，但抽象类中的其它非抽象方法必须有方法体。
5. 抽象类中也可以没有抽象方法。
6. 抽象类中不应该有private的成员（注意是不应该，而不是不能）。不管是成员变量，还是非抽象方法都不建议用private修饰，抽象方法是禁止使用private修饰。原因就是我们创建抽象类的目的就是要实现代码复用，方便子类继承，private修饰的是不能继承的，同时抽象类不能实例化对象，所以用private修饰的成员毫无用处。

抽象类的中抽象方法只允许用public和默认修饰（JDK1.8之前默认是用protected修饰，但在JDK1.8之后则是默认为default修饰）

接口（？？？）

interface关键字使抽象的概念更向前了一步。interface将产生一个完全抽象的类，没有提供任何具体实现。

接口的特点：

1. 允许创建者确定方法名、参数列表和返回类型。但是没有任何方法体。接口只提供了形式并没有提供任何具体实现。
2. 接口中可以包含域（如int，String）但是域默认是static、final的。即默认定为public static final类型的。
3. 接口中的方法必须是public修饰的，默认为public。
4. 接口中的方法不能有方法体。
5. 接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
6. 接口中的方法可以为static int method（）；即defalut static修饰；但是默认修饰方法的还是public abstarct的
7. 在接口中只有方法的声明没有方法体。

接口与抽象类的使用判断：

1. 若要创建不带任何方法定义及成员变量的基类，则选择接口（注意：接口中没有成员变量，只有public static final修饰的常量，且符号要大写）
2. 若知道某事物应该成为一个基类，则第一选择应是使它成为一个接口。

完全解耦—接口的应用？？？（p174）

Java中的多重继承

可以通过接口实现Java的多继承，当将一个具体类和多个接口组合到一起时，这个具体类必须放在前面，后面跟着的才是接口（否则编译器会报错）。

interface CanFight{
    void fight();
}
interface CanSwim{
    void swim();
}
interface CanFly{
    void fly();
}
class ActionCharacter{
    public void fight(){}
}
class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim {
    public void swim() {}
    public void fly() {}
}
public class Adventrue {
    private static void t(CanFight x){x.fight(); }
    private static void u(CanSwim x){x.swim(); }
    private static void v(CanFly x){x.fly(); }
    private static void w(ActionCharacter x){x.fight(); }
    public static void main(String [] args){
        Hero hero = new Hero();
        t(hero);
        u(hero);
        v(hero);
        w(hero);
    }
}

使用接口的核心原因：

1. 为了能够向上转型为多个基类型（由此带来的灵活性）
2. 防止客户端程序员创建该类的对象，并确保这仅仅是建立一个接口

通过继承来扩展接口（？？？）

适配接口（？？？）

接口中的域

初始化接口中的域

在接口中定义的域不能是”空final“，但是可以被非常量的表达式初始化。例如：int RANM_INT = Rand.nextInt(10);.因为域是static的，可以在域第一次加载时就初始化，当然这些域不是接口的一部分，他们的值被存在该接口的静态储存区域中。

嵌套接口（？？？）

接口可以嵌套在类或其他接口中。

接口与工厂

内部类（补）

为什么使用内部类

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响
使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性:
　　(1)、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独。
　　(2)、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
　　(3)、创建内部类对象的时刻并不依赖于外围类对象的创建。
　　(4)、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
　　(5)、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

内部类分类

成员内部类

public class Outer{
        private int age = 99;
        String name = "Coco";
        public class Inner{
            String name = "Jayden";
            public void show(){
                System.out.println(Outer.this.name);
                System.out.println(name);
                System.out.println(age);
            }
        }
        public Inner getInnerClass(){
            return new Inner();
        }
        public static void main(String[] args){
            Outer o = new Outer();
            Inner in = o.new Inner();
            in.show();
        }
    }

1.Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，
如 public 、 protected 、 private 等
2.Inner 类中定义的 show() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，
如直接访问 Outer 类中的私有属性age
3.定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，
即：内部类 对象名 = 外部类对象.new 内部类( );
4.编译上面的程序后，会发现产生了两个 .class 文件: Outer.class,Outer$Inner.class{}
5.成员内部类中不能存在任何 static 的变量和方法,可以定义常量:
(1).因为非静态内部类是要依赖于外部类的实例,而静态变量和方法是不依赖于对象的,仅与类相关,
简而言之:在加载静态域时,根本没有外部类,所在在非静态内部类中不能定义静态域或方法,编译不通过;
非静态内部类的作用域是实例级别
(2).常量是在编译器就确定的,放到所谓的常量池了
★★友情提示:
1.外部类是不能直接使用内部类的成员和方法的，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法;
2.如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，
可以使用 this 关键字,如:Outer.this.name

静态内部类

是 static 修饰的内部类
1.静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2.如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3.创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();

public class Outer{
            private int age = 99;
            static String name = "Coco";
            public static class Inner{
                String name = "Jayden";
                public void show(){
                    System.out.println(Outer.name);
                    System.out.println(name);                  
                }
            }
            public static void main(String[] args){
                Inner i = new Inner();
                i.show();
            }
        }

.方法内部类

访问仅限于方法内或者该作用域内
(1).局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的
(2).只能访问方法中定义的 final 类型的局部变量,因为:
当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在,
直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量;
==>使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.
局部内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，
自己内部的方法调用的实际是自己的属性而不是外部类方法的参数;
防止被篡改数据,而导致内部类得到的值不一致

   /*
        使用的形参为何要为 final???
         在内部类中的属性和外部方法的参数两者从外表上看是同一个东西，但实际上却不是，所以他们两者是可以任意变化的，
         也就是说在内部类中我对属性的改变并不会影响到外部的形参，而然这从程序员的角度来看这是不可行的，
         毕竟站在程序的角度来看这两个根本就是同一个，如果内部类该变了，而外部方法的形参却没有改变这是难以理解
         和不可接受的，所以为了保持参数的一致性，就规定使用 final 来避免形参的不改变
         */
        public class Outer{
            public void Show(){
                final int a = 25;
                int b = 13;
                class Inner{
                    int c = 2;
                    public void print(){
                        System.out.println("访问外部类:" + a);
                        System.out.println("访问内部类:" + c);
                    }
                }
                Inner i = new Inner();
                i.print();
            }
            public static void main(String[] args){
                Outer o = new Outer();
                o.show();
            }
        }    

(3).注意:在JDK8版本之中,方法内部类中调用方法中的局部变量,可以不需要修饰为 final,匿名内部类也是一样的，主要是JDK8之后增加了 Effectively final 功能
http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html
反编译jdk8编译之后的class文件,发现内部类引用外部的局部变量都是 final 修饰的

匿名内部类

(1).匿名内部类是直接使用 new 来生成一个对象的引用;
(2).对于匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，
该类的定义会立即消失，所以匿名内部类是不能够被重复使用;
(3).使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口;
(4).匿名内部类中是不能定义构造函数的,匿名内部类中不能存在任何的静态成员变量和静态方法;
(5).匿名内部类中不能存在任何的静态成员变量和静态方法,匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法
(6).匿名内部类初始化:使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果

  public class OuterClass {
            public InnerClass getInnerClass(final int   num,String str2){
                return new InnerClass(){
                    int number = num + 3;
                    public int getNumber(){
                        return number;
                    }
                };        /* 注意：分号不能省 */
            }
            public static void main(String[] args) {
                OuterClass out = new OuterClass();
                InnerClass inner = out.getInnerClass(2, "chenssy");
                System.out.println(inner.getNumber());
            }
        }
        interface InnerClass {
            int getNumber();
        }      

内部类

可以将一个类的定义放在另一个类的定义内部，这就是内部类。内部类的使用与其他类没有什么不同，但是如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象时，那么必须指明这个对象的类型：OuterClassName.InnerClassName。

public class Parcel2 {
    class Contents {
        private int i = 11;
        public int value() {
            return i;
        }
    }
    class Destination{
        private String label;
        Destination(String whereTo){
            label = whereTo;
        }
        String readLable(){
            return label;
        }
    }
    public Contents contents(){ return new Contents(); }
    public Destination destination(String s){ return new Destination(s); }
    public void ship(String dest){
        Contents c = new Contents();
        Destination d = new Destination(dest);
        System.out.println(d.readLable());
    }
    public static void main(String [] args){
        Parcel2 p = new Parcel2();
        p.ship("Tasmania");
        //defing references to inner class
        Parcel2 q = new Parcel2();
        Parcel2.Contents c = q.contents();
        Parcel2.Destination d = q.destination("borneo");
    }
}

内部类标识符

外围内的名字 + “$” + 内部类的名字.class。如果内部类是匿名的，编译器会简单地产生一个数字作为其标识符。如果内部类是嵌套在别的内部类中，只需直接将他们的名字加在其外围类标识符与“$”后面。

链接到外部类

1. 当生成一个内部类对象时，此对象与制造它的外围对象之间就有了一种联系，所以他就能访问其外围对象的所有成员而不需要任何其他条件。内部类拥有其外围类的所有元素的访问权。
2. 内部类的对象只能在与外围类的对象相关联的情况下才能被创建。构建一个内部类时需要一个指向其外围类对象的引用，如果编译器找不到这个引用则会报错。
3. 外部类访问内部类可以通过几种方式访问：
   方式一：外部类name.内部类name name = 外部类对象.get方法返回内部类new的对象。如 Parcel2.Contents c = q.contents();要求在外部类的contents方法中要返回内部类的new对象。
   方式二：内部类实现了外部的一个接口，则可以 interface name = 外部类.get方法返回内部类的对象。都不能直接在外部类中采用new字段去构造对象再访问，可以用封装在外部类的方法中再new内部类后用方法返回。
   方式三：通过.new去创建

使用.this和.new

1. 要生成对外部类的引用，可以再外部类的名字后紧跟”.this“。这样产生的引用具有正确的类型，且在编译期就被知晓并检查，因此没有任何运行时的开销。

public class DoThis {
    void f(){ System.out.println("DoThis.f()"); }
    public class Inner{
        public DoThis outer(){ return DoThis.this; }  //返回外部类的引用
    }
    public Inner inner(){ return new Inner(); }
    public static void main(String [] args){
        DoThis dt = new DoThis();
        DoThis.Inner di = dt.inner();
        di.outer().f();
    }
}

2. 创建某个内部类的对象，使用“.new”。要创建某个类的对象必须使用外部内的对象来创建该内部类的对象。在拥有外部类对象之前是不可能创建内部类对象的，因为内部类会暗暗地连接到引用它的外部类对象上。但是，如果创建的是嵌套类（静态内部类），那么就不需要对外部类对象的引用。

public class DoNew {
    public class Inner{}
    public static void main(String [] args){
        DoNew dn = new DoNew();
        DoNew.Inner di = dn.new Inner();
    }
}

内部类与向上转型

当将内部类向上转型为其基类，尤其是转型为一个接口时，内部类就发挥很大作用了。因为内部类——某个借口的实现——能够完全不可见，并且不可用。所以得到得只是指向基类或接口的引用，能够很方便的隐藏实现细节。

在方法和作用域内的内部类

可以在一个方法里面或者在任意的作用域内定义内部类。

• 实现某个类型的接口，于是可以创建并返回对其的引用。
• 想创建一个类来辅助解决问题，但不希望这个类是公共可用的。

局部内部类

1. 在方法的作用域内创建一个完整的类。在方法的作用域外是不能访问的。
2. 在方法执行完毕，并不意味着局部内部类就不可以使用了。
3. 可以在同一个子目录的任意类中对局部内部类使用相同的类标识符，这并不会引起命名冲突。

匿名内部类

将返回值的生成与表示这个返回值的类的定义结合在一起。这个类是没有名字的。

public class Parcel7 {
    public Contens contens(){
        return new Contens() {
            private int i = 11;
            public int value() {
                return i;
            }
        };
    }
    public static void main(String [] args){
        Parcel7 p = new Parcel7();
        Contens c = p.contens();
    }
}

匿名内部类的基类如果只有带参构造器，在使用匿名类时可以传递合适的参数给基类的构造器即可。

public class Parcel8 {
    public Wrappping wrappping(int x) {
        return new Wrappping(x) {
            public int value() {
                System.out.println("super.value():  " + super.value());
                return super.value() * 47;
            }
        };
    }
    public static void main(String[] args) {
        Parcel8 p = new Parcel8();
        Wrappping wrappping = p.wrappping(10);
        wrappping.value();
    }
}

在匿名类的末尾的分号，并不是用来标记此内部类结束的，它标识的是表达式的结束，只不过表达式正好包含了匿名内部类。这与别的地方使用的分号是一致的。
在匿名类中定义字段时，还可以初始化。如果匿名内部类希望使用一个在其外部定义的对象，编译器要求参数引用时final的。这个在jdk以前的版本是这样，但是在jdk1.8的时候这一规则不再适用。内部类可以访问外部类中的所有变量无需用final修饰了

public class Parcel9 {
    public Destination destination( /*final*/  String dest){
        return new Destination() {
            private String label = dest;
            public String readLabel() {
                return label;
            }
        };
    }
    public static void main(String [] args){
        Parcel9 p = new Parcel9();
        Destination d = p.destination("sdcsd");
    }
}

匿名内部类既可以扩展类也可以实现接口，但是在实现接口时变不能继承，继承时便不能实现接口，而且实现接口时只能实现一个接口。

嵌套类

嵌套类：不需要内部类对象与其外围类对象有联系，那么可以将内部类声明为static。普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含所有的这些东西。

接口中的类

接口中的任何类修饰都是public和static的，可以在接口中的内部类实现其外围接口。如果想创建某些公共代码，使得他们都可以被某个接口的的所有不同实现所共用，name使用接口内部的嵌套类会很方便。