Java 面向对象（6）

你的名字 2021-05-03 16:29 556阅读 0赞

# 内部类 #

当描述事物时，事物的内部还有事物，该事物用内部类表示。因为内部事物在使用外部事物的内容。

## 优点： ##

1.  内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象。如同心脏可以直接访问身体的血液，而不是通过医生来抽血
2.  每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
3.  在我们程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
````
    public interface Father { 
    
    }
    public interface Mother { 
    
    }
    public class Son implements Father, Mother { 
    
    }
    public class Daughter implements Father{ 
        class Mother_ implements Mother{ 
    
        }
    }
````
内部类还能够为我们带来如下特性：  
1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相 互独立。  
2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类  
3、创建内部类对象的时刻并不依赖于外围类对象的创建。  
4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。  
5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

## 成员内部类： ##

成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。  
成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的

class Outer 
    {
        private int x=3;
        class Inner
        {
            int x=4;
            void show()
            {
                System.out.print(Outer.this.x); //访问外部类中的成员
            }
        }
    }
    class Test
    {
        public static void main(String[] args)
        {
            Outer.Inner in=new Outer().new Inner(); //外部其他类中创建内部类对象
            in.show();
        }
    }

## 局部内部类： ##

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。  
内部类定义在局部时：  
1. 不可以被成员修饰符修饰  
2. 可以直接访问外部类中的成员，但是不能访问它所在的局部中的变量（除非该局部变量被final修饰）

**定义在方法里：**

public class Outer {
        int x=3;
        void method()
        {
            final int y=4;  //不加final编译无法通过
            class Inner
            {
                void show()
                {
                    System.out.println(x);
                    System.out.println(y);
                }
            }
            new Inner().show();
        }
    }
    public class Test {
    
        public static void main(String[] args) {
            new Outer().method();
        }
    
    }
    ----------------
    Output:
    3
    4

**定义在作用域内:**

public class Parcel6 {
        private void internalTracking(boolean b){
            if(b){
                class TrackingSlip{
                    private String id;
                    TrackingSlip(String s) {
                        id = s;
                    }
                    String getSlip(){
                        return id;
                    }
                }
                TrackingSlip ts = new TrackingSlip("chenssy");
                String string = ts.getSlip();
            }
        }
    
        public void track(){
            internalTracking(true);
        }
    
        public static void main(String[] args) {
            Parcel6 parcel6 = new Parcel6();
            parcel6.track();
        }
    }

## 静态内部类： ##

使用static修饰的内部类我们称之为静态内部类（也称嵌套内部类）。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：  
（1） 它的创建是不需要依赖于外围类的。  
（2） 它不能使用任何外围类的非static成员变量和方法。

public class OuterClass { 
        private String sex;
        public static String name = "chenssy";
        /** *静态内部类 */
        static class InnerClass1{
            /* 在静态内部类中可以存在静态成员 */
            public static String _name1 = "chenssy_static";
    
            public void display(){
                /* * 静态内部类只能访问外围类的静态成员变量和方法 * 不能访问外围类的非静态成员变量和方法 */
                System.out.println("OutClass name :" + name);
            }
        }
    
        /** * 非静态内部类 */
        class InnerClass2{
            /* 非静态内部类中不能存在静态成员 */
            public String _name2 = "chenssy_inner";
            /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */
            public void display(){
                System.out.println("OuterClass name：" + name);
            }
        }
    
        /** * 外围类方法 */
        public void display(){
            /* 外围类访问静态内部类：内部类. */
            System.out.println(InnerClass1._name1);
            /* 静态内部类 可以直接创建实例不需要依赖于外围类 */
            new InnerClass1().display();
    
            /* 非静态内部的创建需要依赖于外围类 */
            OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
            /* 方位非静态内部类的成员需要使用非静态内部类的实例 */
            System.out.println(inner2._name2);
            inner2.display();
        }
    
        public static void main(String[] args) {
            OuterClass outer = new OuterClass();
            outer.display();
        }
    }
    ----------------
    Output:
    chenssy_static
    OutClass name :chenssy
    chenssy_inner
    OuterClass name：chenssy

## 匿名内部类： ##

匿名内部类其实就是内部类的简写格式，是一个带内容的匿名子类对象。。使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。

public abstract class Absdemo {
        abstract void show();
    }
    public class Outer {
        int x=3;
        public void function()
        {
            //匿名内部类
            new Absdemo()   
            {
                void show()
                {
                    System.out.println(x);
                }
            }.show(); //可以在此处调用方法
        }
    }
    public class Test {
        public static void main(String[] args) {
            new Outer().function();
        }
    }

这里的new Absdemo() 是父类Absdemo的匿名子类对象  
**注意：**  
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。  
2、匿名内部类中是不能定义构造函数的。  
3、匿名内部类中不能存在任何的静态成员变量和静态方法。  
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。  
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。  
**匿名内部类初始化：**  
我们一般都是利用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！那怎么来初始化匿名内部类呢？使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果。