java基础：静态内部类和非静态内部类对外部类属性的使用 |
您所在的位置：网站首页 › 如东晨园开发商是哪家 › java基础：静态内部类和非静态内部类对外部类属性的使用 |
java基础：静态内部类和非静态内部类对外部类属性的使用
|
public class InnerClassTest {
int a = 1;
static int b = 2;
private int c = 3;
private static int d = 4;
//非静态内部类
class Inner1{
void test(){
System.out.println(a); //外部类属性
System.out.println(b); //外部类静态属性
System.out.println(c); //外部私有类属性
System.out.println(d); //外部静态私有类属性
}
}
//静态内部类
static class Inner2{
void test(){
System.out.println(a); //外部类属性 有错误
System.out.println(b); //外部类静态属性
System.out.println(c); //外部私有类属性 有错误
System.out.println(d); //外部静态私有类属性
}
}
}
非静态内部类 1.可以访问外部类的非静态属性，包括私有属性 2.可以访问外部类的静态属性，包括静态私有属性 静态内部类 1.只可以访问外部类的静态属性，包括静态私有属性 2.不可以可以访问外部类的非静态属性，包括私有属性
public class Outer { public String name = "MAH"; public class Inner //非静态内部类 { public int Num = 4;//非静态内部类的Feild public void acc() { System.out.println(name);//非静态内部类可以直接访问外部类的成员 } } public void accessInner() { System.out.println("内部类的Num值是：" + new Inner().Num); } public static void main(String[] args) { Outer b = new Outer(); System.out.println("这是外部类的主方法" + b.name); b.accessInner(); //外部类通过调用accessInner方法产生一个非静态内部类的实例 } } 非静态内部类可以直接访问外部类的成员，而外部类不可以直接访问非静态内部类的成员 原因： 非静态内部类没有被static修饰，所以这个内部类就不是类相关的，也就说不是类的，是实例的， 但是我们非静态内部类要创建实例，外部类一定会先创建一个外部类的实例，非静态内部类的实例就是寄生在外部类的实例上的。所以，非静态内部类的实例可以直接访问外部类的成员，因为，外部类已经创建一个实例的，内部类保留了外部类创建的实例的引用 静态内部类不一样！ 静态内部类是被static修饰的，所以是类的一员。根据静态成员不能访问非静态成员的原则，静态内部类是不能访问外部类的非静态成员的
java中的类可以是static吗？答案是可以。在java中我们可以有静态实例变量、静态方法、静态块。类也可以是静态的。 java允许我们在一个类里面定义静态类。比如内部类（nested class）。把nested class封闭起来的类叫外部类。在java中，我们不能用static修饰顶级类（top level class）。只有内部类可以为static。 静态内部类和非静态内部类之间到底有什么不同呢？下面是两者间主要的不同。 （1）内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。 （2）非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。 （3）一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面。 基于上面的讨论，我们可以通过这些特性让编程更简单、有效。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 /* 下面程序演示如何在java中创建静态内部类和非静态内部类 */ class OuterClass{ private static String msg = "GeeksForGeeks"; // 静态内部类 public static class NestedStaticClass{ // 静态内部类只能访问外部类的静态成员 public void printMessage() { // 试着将msg改成非静态的，这将导致编译错误 System.out.println("Message from nested static class: " + msg); } } // 非静态内部类 public class InnerClass{ // 不管是静态方法还是非静态方法都可以在非静态内部类中访问 public void display(){ System.out.println("Message from non-static nested class: "+ msg); } } } class Main { // 怎么创建静态内部类和非静态内部类的实例 public static void main(String args[]){ // 创建静态内部类的实例 OuterClass.NestedStaticClass printer = new OuterClass.NestedStaticClass(); // 创建静态内部类的非静态方法 printer.printMessage(); // 为了创建非静态内部类，我们需要外部类的实例 OuterClass outer = new OuterClass(); OuterClass.InnerClass inner = outer.new InnerClass(); // 调用非静态内部类的非静态方法 inner.display(); // 我们也可以结合以上步骤，一步创建的内部类实例 OuterClass.InnerClass innerObject = new OuterClass().new InnerClass(); // 同样我们现在可以调用内部类方法 innerObject.display(); } }
一：成员内部类： 最常见的内部类就是成员内部类，也称作普通内部类； 1、Inner类定义在Outer类的内部，相当于Outer类的成员变量的位置，Inner类可以使用任意访问修饰符，如：public、private、protected等。 2、Inner类中定义的test()方法可以访问Outer类中的数据，不受访问控制符的影响。 3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );如创建Inner的内部类对象：要先创建外部类对象：Outer o = new outer(); 创建内部类：Inner i = o.new Inner();访问Inner中的test()方法：i.test(); 例如： 4、如果外部类和内部类具有相同的成员变量或方法，内部类可以直接访问内部类的成员变量或方法，但如果内部类访问外部类的成员变量或者方法时，需要使用this关键字；如下： 二：静态内部类 静态内部类就是用static修饰的内部类，这种内部类的特点是： 1、静态内部类不能直接访问外部类的非静态成员，但，可以通过new 外部类().成员的方式访问； 2、如果外部类的静态成员与内部类的静态成员相同， 可以通过"类名.静态成员"来访问外部类的静态成员；如果不同，可以直接调用外部类的静态成员名。 3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建； 三：方法内部类： 1、方法内部类就是定义在外部类的方法中，方法内部类只在该方法内可以用； 2、由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
Java内部类 本文将通过WHAT、WHY、HOW三个方面来展开Java内部类的相关知识。 文章目录 Java内部类 一、什么是内部类？二、为什么要用内部类？三、如何使用内部类 （一）成员内部类 1、外部类、内部类2、其他类使用成员内部类3、运行结果（和innerShow()方法对照）：4、小结：【成员内部类当成Outer的成员信息存在 】（二）静态内部类 1、外部类、内部类2、其他类使用成员内部类3、运行结果（注意加载顺序）4、小结【和成员内部类对比理解（区别异同）】（三）局部内部类 1、外部类、内部类2、运行结果3、小结【局部内有很多局限，应注意作用域】4、局部内部类访问局部变量的限制（四）匿名内部类 1、定义接口2、匿名内部类使用3、结果4、小结【匿名内部类常常被用来重写某个或某些方法】 一、什么是内部类？ 可以将一个类的定义放在里另一个类的内部，这就是内部类。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。 /** * 我是一个外部类（外部是相对内部而言） */ public class Outer{ /** * 我是一个内部类 */ class Inner{ //... } } 二、为什么要用内部类？使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。——《Think in java》 也就是说内部类拥有类的基本特征。(eg：可以继承父类，实现接口。)在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。（注：内部类可以嵌套内部类，但是这极大的破坏了代码的结构，这里不推荐使用。） /** 1. Outer类继承了ClassA，实现了IFunctionA */ public class Outer extends ClassA implements IFunctionA{ /** * Inner类继承了ClassB，实现了IFunctionB */ public class Inner extends ClassB implements IfunctionB{ // } }除了上面的优点之外还有如下四点： 1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。 2、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。 3、内部类提供了更好的封装，除了该外围类，其他类都不能访问。 4、创建内部类对象的时刻并不依赖于外围类对象的创建。 具体来说，内部类信息（属性、方法）可以和外部类重名；内部类是具有类的基本特征的独立实体；可以利用访问修饰符隐藏内部类的实施细节，提供了更好的封装；静态内部类使用时可直接使用，不需先创造外部类。 三、如何使用内部类简单的总结如下（暂时不太理解也没有关系，我们下面会通过例子依此演示）： 1、外部类、内部类 /** * 外部类、成员内部类的定义 */ 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(); } }2、其他类使用成员内部类 /* * 其他类使用成员内部类 */ public class Other { public static void main(String[] args) { //外部类对象 Outer outer = new Outer(); //创造内部类对象 Outer.Inner inner = outer.new Inner(); inner.innerShow(); /* * 可在Outer中定义get方法，获得Inner对象,那么使用时，只需outer.getInnerInstance()即可。 * public Inner getInnerInstance(Inner类的构造方法参数){ * return new Inner(参数); * } */ } }3、运行结果（和innerShow()方法对照）：
4、小结：【成员内部类当成Outer的成员信息存在 】 可以是任何的访问修饰符。内部类的内部不能有静态信息。内部类也是类,该继承继承，该重写重写，该重载重载，this和super随便用。外部类如何访问内部类信息，必须new之后打点访问。内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。其它类如何访问内部类： Outer outer=new Outer(); //创造内部类对象 Outer.Inner inner=outer.new Inner(); inner.inner_show(); （二）静态内部类1、外部类、内部类 /** * 外部类、内部类定义 */ 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(); } }2、其他类使用成员内部类 public class Other { public static void main(String[] args) { //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。 Outer.Inner.innerStaticShow(); //访问静态内部类的成员方法 Outer.Inner oi = new Outer.Inner(); oi.innerShow(); } }3、运行结果（注意加载顺序） 4、小结【和成员内部类对比理解（区别异同）】 内部可以包含任意的信息。静态内部类的方法只能访问外部类的static关联的信息。利用 外部类.内部类 引用=new 外部类.内部类(); 然后利用引用.成员信息(属性、方法)调用。访问内部类的静态信息，直接外部类.内部类.静态信息就可以了。静态内部类可以独立存在，不依赖于其他外围类。 （三）局部内部类1、外部类、内部类 /** * 外部类、内部类 */ 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(); } }2、运行结果 3、小结【局部内有很多局限，应注意作用域】 类前不能有访问修饰符。仅在此方法内使用。无法创造静态信息。可以直接访问方法内的局部变量和参数（有限制，下面详谈），但是不能更改。可以随意的访问外部类的任何信息。4、局部内部类访问局部变量的限制 Variable ‘xxx’ is accessed from within inner class, needs to be final or effectively final 它的意思是：变量’xxx’从内部类中访问，需要final或有效的final 具体限制如下： 直接被final修饰的变量。已被赋值且始终未改变的变量（有且仅有赋值一次）,引用指向不能改变。JDK8以前（不包括8）只能访问被final修饰的变量。eg: 就会产生如下错误：传入局部内部类所在方法的参数同理，如果一直不变则可使用，反之则会报错。
（四）匿名内部类
1、定义接口 /** * 接口中方法默认为public */ public interface IAnimal{ void speak(); }2、匿名内部类使用 /** * 外部内、内部类 */ 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("小狗汪汪汪！").speak(); } }3、结果 小狗汪汪汪！ 4、小结【匿名内部类常常被用来重写某个或某些方法】 匿名内部类是没有访问修饰符的。使用匿名内部类时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。匿名内部类访问方法参数时也有和局部内部类同样的限制。匿名内部类没有构造方法。JVM的类加载规则 ： 1. static类型的属性和方法，在类加载的时候就会存在于内存中。 2. 要想使用某个类的static属性和方法，那么这个类必须要加载到JAVA虚拟机中。 3. 非静态内部类并不随外部类一起加载，只有在实例化外部类之后才会加载。 现在考虑这个情况：在外部类并没有实例化，内部类还没有加载，这时候如果 调用内部类的静态成员或方法，内部类还没有加载，却试图在内存中创建该内 部类的静态成员，这明显是矛盾的。所以非静态内部类不能有静态成员变量或 静态方法。 假设 ：在外部类并没有实例化，内部类还没有加载，这时候如果JVM加载静 态成员或方法，内部类还没有加载，因为非静态内部类的加载依赖于实化， 而此时却试图在内存中创建该内部类的静态成员，这明显是矛盾的。所以非 静态内部类不能有静态成员变量或静态方法。
|
我们通过一些demo来理解如何使用内部类
【本文地址】