【Java SE基础九】Java内部类_9、如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量-CSDN博客

本文链接：https://blog.csdn.net/sinat_33087001/article/details/114866758

在Java编程语言里，程序是由类(class)构建而成的。在一个类的内部也可以声明类，我们把这样的类叫做内部类，一个简单内部类的定义如下：

public class Outer{
	/**
	*	我是一个内部类
	*/
	class Inner{
	//...
	}
}

为什么使用内部类

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响，也就是说内部类拥有类的基本特征，可以继承父类，实现接口

/**
 1. Outer类继承了ClassA，实现了IFunctionA
*/
public class Outer extends ClassA implements IFunctionA{ 
	/**
	*	Inner类继承了ClassB，实现了IFunctionB
	*/
	public class Inner extends ClassB implements IfunctionB{
	//
	} 
}

内部类特性

使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性

内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外部对象的信息相互独立。
在单个外部类中，多个内部类能以不同的方式实现同一个接口，或者继承同一个类。
创建内部类对象的时刻并不依赖于外围类对象的创建
内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
内部类提供了更好的封装，除了该外部类，其他类都不能访问。

总结而言该内部类更像是外部类的一部分。

内部类使用原则

内部类和外部类的使用原则主要分为以下几点：

外部类只能用public访问修饰符，但内部类可以使用所有的访问修饰符， public 、 protected 、 private 等
类的使用：外部类直接实例化即可使用，实例化的外部类里边没有关于内部类的东西，基本上外部类的使用可以忽视内部类；内部类的使用需要先实例化外部类对象，即：内部类对象名 = 外部类对象.new 内部类( );
内部类可以直接访问并且调用外部类的字段，但优先执行本内部类内部的字段方法。执行顺序：本内部类方法->方法外->外部类，如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字,如:Outer.this.name
外部类的所有字段无论是否private对于内部类都没有任何隐私可言
外部类不能直接访问内部类，但可以通过实例化直接当成一个普通的数据类型一样访问。直接new 内部类
内部类不定义为public也默认设定为同一包可访问，如果想不同包访问，必须定义为public类型

以上就是外部类和内部类的通用区分方式

内部类有哪几种

内部类分为成员内部类、静态内部类、局部内部类和匿名内部类。

成员内部类

以下为一个成员内部类的定义，其使用方式如下：

package com.company;


/**
 * 外部类、成员内部类的定义
 */
public class Outer {

    private int outerVariable = 1;
    private int commonVariable = 2;
    private static int outerStaticVariable = 3;
    //省略getter/setter

    /**
     * 成员方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 内部类
     */
    public class Inner {

        private int commonVariable = 20;

        /**
         * 构造方法
         */
        public Inner() {
        }

        /**
         * 成员方法，访问外部类信息（属性、方法）
         */
        public void innerShow() {
            //当和外部类冲突时，直接引用属性名，是内部类的成员属性
            System.out.println("内部的commonVariable:" + commonVariable);
            //内部类访问外部属性
            System.out.println("outerVariable:" + outerVariable);
            //当和外部类属性名重叠时，可通过外部类名.this.属性名
            System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
            System.out.println("outerStaticVariable:" + outerStaticVariable);
            //访问外部类的方法
            outerMethod();
            outerStaticMethod();
        }
    }

    /**
     *	外部类访问内部类信息
     */
    public void outerShow() {
        Inner inner = new Inner();
        inner.innerShow();
    }
    public static void main(String[] args){
        Outer o = new Outer();
        System.out.println("外部类的方法调用==================");
        o.outerShow();
        System.out.println("内部类的初始化调用==================");
        Inner in = o.new Inner();
        in.innerShow();
    }
}

执行结果如下：

外部类的方法调用==================
内部的commonVariable:20
outerVariable:1
外部的commonVariable:2
outerStaticVariable:3
我是外部类的outerMethod方法
我是外部类的outerStaticMethod静态方法
内部类的初始化调用==================
内部的commonVariable:20
outerVariable:1
外部的commonVariable:2
outerStaticVariable:3
我是外部类的outerMethod方法
我是外部类的outerStaticMethod静态方法

以上内容分条解释如下：

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

以上就是成员内部类的使用说明，成员内部类可以类比一个非静态成员。

静态内部类

以下为一个静态内部类的定义，其使用方式如下：

package com.company;


/**
 * 外部类、成员内部类的定义
 */
public class Outer {

    private int outerVariable = 1;

    /**
     * 外部类定义的属性(重名)
     */
    private int commonVariable = 2;

    private static int outerStaticVariable = 3;

    static {
        System.out.println("Outer的静态块被执行了……");
    }

    /**
     * 成员方法
     */
    public void outerMothod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /*
     *	静态方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }


    /**
     * 静态内部类
     */
    public static class Inner {
        /**
         * 成员信息
         */
        private int innerVariable = 10;
        private int commonVariable = 20;

        static {
            System.out.println("Outer.Inner的静态块执行了……");
        }

        private static int innerStaticVariable = 30;

        /**
         * 成员方法
         */
        public void innerShow() {
            System.out.println("innerVariable:" + innerVariable);
            System.out.println("内部的commonVariable:" + commonVariable);
            System.out.println("outerStaticVariable:"+outerStaticVariable);
            outerStaticMethod();
            
        }

        /**
         * 静态方法
         */
        public static void innerStaticShow() {
            //被调用时会先加载Outer类
            outerStaticMethod();
            System.out.println("outerStaticVariable"+outerStaticVariable);
        }
    }

    /**
     * 外部类的内部如何和内部类打交道
     */
    public static void callInner() {
        System.out.println(Inner.innerStaticVariable);
        Inner.innerStaticShow();
    }
    public static void main(String[] args){
        //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
        Outer.Inner.innerStaticShow();
        //访问静态内部类的成员方法
        Outer.Inner oi = new Outer.Inner();
        oi.innerShow();
        Inner in=new Inner();
        in.innerShow();
    }
}

返回结果为：

Outer的静态块被执行了……
Outer.Inner的静态块执行了……
我是外部类的outerStaticMethod静态方法
outerStaticVariable3
innerVariable:10
内部的commonVariable:20
outerStaticVariable:3
我是外部类的outerStaticMethod静态方法

静态内部类和成员内部类有几点不同：

静态内部类可以包含任意的信息，静态或非静态，因为它不依赖于外部类的实例对象，所以可以有静态成员
静态内部类的方法只能访问外部类的static修饰的信息。
访问静态内部类的静态信息直接Outer.Inner.innerStaticShow();即可
访问静态内部类的非静态信息Outer.Inner oi = new Outer.Inner();，然后oi.innerShow();即可
静态内部类可以独立存在，不依赖于其他外部类。创建静态内部类的对象时，不需要外部类的实例对象，可以直接创建 内部类对象名 = new 内部类();
如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

总而言之静态内部类的加载只依赖于外部类的类对象而非实例对象。更加的独立，静态内部类可以类比一个静态成员。

局部内部类

以下为一个静态内部类的定义，其使用方式如下：

/**
 *	外部类、内部类
 */
public class Outer {
    /**
     * 属性和方法
     */
    private int outerVariable = 1;
    /**
     * 外部类定义的属性
     */
    private int commonVariable = 2;
    /**
     * 静态的信息
     */
    private static int outerStaticVariable = 3;

    /**
     * 成员外部方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态外部方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 程序的入口
     */
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerCreatMethod(100);
    }

    /**
     * 成员方法，内部定义局部内部类
     */
    public void outerCreatMethod(int value) {
        /**
         * 女性
         */
        boolean sex = false;

        /**
         * 局部内部类，类前不能有访问修饰符
         */
        class Inner {

            private int innerVariable = 10;
            private int commonVariable = 20;
			/**
			*	局部内部类方法
			*/
            public void innerShow() {
                System.out.println("innerVariable:" + innerVariable);
                //局部变量
                System.out.println("是否男性:" + sex);
                System.out.println("参数value:" + value);
                //调用外部类的信息
                System.out.println("outerVariable:" + outerVariable);
                System.out.println("内部的commonVariable:" + commonVariable);
                System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
                System.out.println("outerStaticVariable:" + outerStaticVariable);
                outerMethod();
                outerStaticMethod();
            }
        }
        //局部内部类只能在方法内使用
        Inner inner = new Inner();
        inner.innerShow();
    }
}

返回结果如下：

innerVariable:10
是否男性:false
参数value:100
outerVariable:1
内部的commonVariable:20
外部的commonVariable:2
outerStaticVariable:3
我是外部类的outerMethod方法
我是外部类的outerStaticMethod静态方法

相比成员内部类和静态内部类，局部内部类有很多限制：

局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。
局部内部类无法包含静态成员。
局部内部类可以直接访问方法内的局部变量和参数，只能访问方法中定义的 final 类型的局部变量，但是不能更改。
局部内部类可以随意的访问外部类的任何信息。

当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在, 直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量，使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.局部内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数;防止被篡改数据,而导致内部类得到的值不一致，局部内部类可以类比一个方法参数。

匿名内部类

以下为一个匿名内部类的定义，其使用方式如下，首先定义接口

/**
*	接口中方法默认为public 
*/
public interface IAnimal{
	void speak();
}

然后使用匿名内部类：


/**
*	外部内、内部类
*/
public class Outer {

    public static IAnimal getInnerInstance(String speak){
        return new IAnimal(){
            @Override
            public void speak(){
                System.out.println(speak);
            }};
        	//注意上一行的分号必须有
    }
    
    public static void main(String[] args){
    	//调用的speak()是重写后的speak方法。
        Outer.getInnerInstance("TTTTTTT").speak();
    }
}

返回结果

TTTTTTT

匿名内部类在我们简化代码的时候还是蛮常见的

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

匿名内部类可以类别一个方法返回值。