1.什么是内部类？
将一个java将类定义为另一类类体，然后将类体定义为内部类体 我们包括内部类java类叫外部类 public class Hello{
public class World{
}
}
Hello---外部类 World---内部类 编译后，内部类将获得独立的内部类字节码文件外部类名称$内部类名.class】
2.内部分类？
1.成员内部类 2.内部类的方法 3.匿名内部类 4.静态内部类静态嵌套类
3.各种内部类的写作形式及其特点
将内部类定义为另一类 public class Hello{ ///成员内部类 public class World{
} }
package com.wangxing.chengyuan.test1; public class Hello { ///成员内部类 public class World{ public String worldshili="成员内部类中的实例变量"; ///没有静态变量 //public static String worldstatic="成员内部静态变量"; public World(){ System.out.println("成员内部类中的构造方法"); } public void worldShiLiMethod(){ System.out.println("成员内部类中的实例方法"); } ///没有静态方法 //public static void worldStaticMethod(){ // System.out.println("成员内部静态方法"); //} } }方法可以访问成员内部类中的实例变量/实例方法，构造方法 1.实例变量/实例方法.实例变量/实例方法，this.实例变量/实例方法，对象和this可以省略 2.通过结构方法，通过new访问。
package com.wangxing.chengyuan.test1; public class Hello2 { ///成员内部类 public class World2{ public String worldshili="成员内部类中的实例变量"; public World2(){ System.out.println("成员内部类中的构造方法"); } public World2(String name){ World2 w2=new World2(); System.out.println(w2.worldshili); System.out.println(this.worldshili); System.out.println(worldshili); w2.worldShiLiMethod1(); this.worldShiLiMethod1(); worldShiLiMethod1(); } public void worldShiLiMethod1(){ System.out.println("成员内部类中的实例方法"); } public void worldShiLiMethod2(){ System.out.println("成员内部类中的实例方法"); World2 w2=new World2(); System.out.println(w2.worldshili); System.out.println(this.worldshili); System.out.println(worldshili); w2.worldShiLiMethod1(); this.worldShiLiMethod1(); worldShiLiMethod1(); } } }外部实例变量/实例方法、静态变量/静态方法、结构方法 1.访问实例变量/实例方法，对象.实例变量/实例方法，外部类名.this.实例变量/实例方法，对象/外部类名.this可以省略。 2.访问静态变量/静态方法，访问对象.静态变量/静态方法，外部类名.this.静态变量/静态方法，外部类名.静态变量/静态方法，对象/外部类名.this可以省略外部类名。 3.通过结构方法访问，通过new访问
package com.wangxing.chengyuan.test1; public class Hello3 { public String helloshili="外部类中的实例变量"; public static String hellostatic="外部类中的静态变量"; public Hello3(){ System.out.println("外部结构方法"); } public void helloShiLi(){ System.out.println("外部实例法"); } public static void helloStatic(){ System.out.println("外部静态方法"); } ///成员内部类 public class World3{ public World3(){ Hello3 h3=new Hello3(); System.out.println(h3.helloshili); System.out.println(Hello3.this.helloshili); System.out.println(helloshili); System.out.println(h3.hellostatic); System.out.println(Hello3.this.hellostatic); System.out.println(Hello3.hellostatic); System.out.println(hellostatic); h3.helloShiLi(); Hello3.this.helloShiLi(); helloShiLi(); h3.helloStatic(); Hello3.this.helloStatic(); Hello3.helloStatic(); helloStatic(); } public void worldShiLiMethod1(){ Hello3 h3=new Hello3(); System.out.println(h3.helloshili); System.out.println(Hello3.this.helloshili); System.out.println(helloshili); System.out.println(h3.hellostatic); System.out.println(Hello3.this.hellostatic); System.out.println(Hello3.hellostatic); System.out.println(hellostatic); h3.helloShiLi(); Hello3.this.helloShiLi(); helloShiLi(); h3.helloStatic(); Hello3.this.helloStatic(); Hello3.helloStatic(); helloStatic(); } } }在外部类的结构方法/实例方法中，可以访问成员内部类的实例变量/实例方法，只能访问对象，不能省略。 成员内部类的元素不能在外部类的静态方法中访问。
package com.wangxing.chengyuan.test1; public class Hello4 { public String helloshili="外部类中的实例变量;
public static String hellostatic="外部类中的静态变量";
public Hello4(){
System.out.println("外部类的构造方法");
World4 w4=new World4();
System.out.println(w4.worldshili);
w4.worldShiLiMethod1();
}
public void helloShiLi(){
System.out.println("外部类的实例方法");
World4 w4=new World4();
System.out.println(w4.worldshili);
w4.worldShiLiMethod1();
}
public static void helloStatic(){
System.out.println("外部类的静态方法");
//World4 w4=new World4();
//System.out.println(w4.worldshili);
//w4.worldShiLiMethod1();
}
//成员内部类
public class World4{
public String worldshili="成员内部类中的实例变量";
public World4(){
System.out.println("成员内部类中的构造方法");
}
public void worldShiLiMethod1(){
System.out.println("成员内部类中的实例方法");
}
}
}其他类中访问成员内部中的元素 1.外部类名.内部类名 w1=new 外部类构造方法().new 内部类构造方法();
2.外部类名 外部类对象=new 外部类构造方法(); 外部类名.内部类名 w1=外部类对象.new 内部类构造方法();
3.import 包名.外部类名.内部类名; 3.1 内部类名 w1=new 外部类构造方法().new 内部类构造方法(); 3.2 外部类名 外部类对象=new 外部类构造方法(); 内部类名 w1=外部类对象.new 内部类构造方法();
package com.wangxing.chengyuan.test1;
public class Hello {
//成员内部类
public class World{
public String worldshili="成员内部类中的实例变量";
public World(){
System.out.println("成员内部类中的构造方法");
}
public void worldShiLiMethod(){
System.out.println("成员内部类中的实例方法");
}
}
}
package com.wangxing.chengyuan.test1;
import com.wangxing.chengyuan.test1.Hello.World;
public class Other {
public Other(){
Hello.World w1=new Hello().new World();
System.out.println(w1.worldshili);
w1.worldShiLiMethod();
}
public void shili(){
Hello hello=new Hello();
Hello.World w1=hello.new World();
System.out.println(w1.worldshili);
w1.worldShiLiMethod();
}
public static void staticmethod(){
Hello hello=new Hello();
World w1=hello.new World();
System.out.println(w1.worldshili);
w1.worldShiLiMethod();
}
}将一个java类定义在另一个类的方法中 1.我们可以在一个java类中的任意一个方法中定义方法内部类 2.定义在方法中的方法内部类不能使用任何访问限制修饰符
package com.wangxing.test1;
public class Hello {
public Hello(){
class TestWorld{
}
}
public void shiliMethod(){
class World{
}
}
public static void staticMethod(){
class MyWorld{
}
}
}方法内部类中可以定义实例变量/实例方法，构造方法，不能有静态变量/静态方法。
package com.wangxing.test1;
public class Hello1 {
public void shiliMethod(){
class World{
public String worldshili="方法内部类的实例变量";
//方法内部类中不能有静态变量
//public static String worldstatic="方法内部类的静态变量";
public World(){
System.out.println("方法内部类的构造方法");
}
public void wordMethod(){
System.out.println("方法内部类的实例方法");
}
//方法内部类中不能有静态方法
//public static void wordStaticMethod(){
// System.out.println("方法内部类的静态方法");
//}
}
}
}1.对构造方法的访问，通过new方法 2.对实例变量/实例方法的访问，this.实例变量/实例方法,对象.实例变量/实例方法,this和对象可以省略
package com.wangxing.test1;
public class Hello2 {
public void shiliMethod(){
class World{
public String worldshili="方法内部类的实例变量";
public World(){
System.out.println("方法内部类的构造方法");
}
public World(String name){
System.out.println("方法内部类的构造方法");
World w1=new World();
System.out.println(this.worldshili);
System.out.println(w1.worldshili);
System.out.println(worldshili);
this.wordMethod1();
w1.wordMethod1();
wordMethod1();
}
public void wordMethod1(){
System.out.println("方法内部类的实例方法");
}
public void wordMethod2(){
System.out.println("方法内部类的实例方法");
World w1=new World();
System.out.println(this.worldshili);
System.out.println(w1.worldshili);
System.out.println(worldshili);
this.wordMethod1();
w1.wordMethod1();
wordMethod1();
}
}
}
}方法内部类中可以访问定义该方法内部类的方法里的局部变量，方法里的局部变量默认final修饰符修饰，为常量，可以直接变量名称访问。
package com.wangxing.test1;
public class Hello3 {
public void shiliMethod(){
//默认使用final修饰符修饰的变量
final String jububialiang="局部变量";
//String jububialiang="局部变量";
class World{
public String worldshili="方法内部类的实例变量";
public World(){
System.out.println("方法内部类的构造方法");
//jububialiang="方法局部变量";
System.out.println(jububialiang);
}
public void wordMethod1(){
System.out.println("方法内部类的实例方法");
//jububialiang="方法局部变量";
System.out.println(jububialiang);
}
}
}
}
1.对构造方法的访问，通过new访问 2.对实例元素的访问，对象.实例元素,外部类类名.this.实例元素,对象/外部类类名.this可以省略。 3.对静态元素的访问，对象.静态元素,外部类类名.this.静态元素,外部类类名.静态元素,对象/外部类类名.this/外部类类名可以省略。
package com.wangxing.test1;
public class Hello4 {
public String waishili="外部类的实例变量";
public static String waistatic="外部类的静态变量";
public Hello4(){
System.out.println("外部类的构造方法");
}
public void waiShiLiMethod(){
System.out.println("外部类的实例方法");
}
public static void waiStaticMethod(){
System.out.println("外部类的静态方法");
}
public void shiliMethod(){
final String jububialiang="局部变量";
class World{
public String worldshili="方法内部类的实例变量";
public World(){
System.out.println("方法内部类的构造方法");
//1.对构造方法的访问，通过new访问
Hello4 h4=new Hello4();
//2.对实例元素的访问，对象.实例元素,外部类类名.this.实例元素,
//对象/外部类类名.this可以省略。
System.out.println(h4.waishili);
System.out.println(Hello4.this.waishili);
System.out.println(waishili);
h4.waiShiLiMethod();
Hello4.this.waiShiLiMethod();
waiShiLiMethod();
//3.对静态元素的访问，对象.静态元素,外部类类名.this.静态元素,外部类类名.静态元素,
//对象/外部类类名.this/外部类类名可以省略。
System.out.println(h4.waistatic);
System.out.println(Hello4.this.waistatic);
System.out.println(Hello4.waistatic);
System.out.println(waistatic);
h4.waiStaticMethod();
Hello4.this.waiStaticMethod();
Hello4.waiStaticMethod();
waiStaticMethod();
}
public void wordMethod1(){
System.out.println("方法内部类的实例方法");
//1.对构造方法的访问，通过new访问
Hello4 h4=new Hello4();
//2.对实例元素的访问，对象.实例元素,外部类类名.this.实例元素,
//对象/外部类类名.this可以省略。
System.out.println(h4.waishili);
System.out.println(Hello4.this.waishili);
System.out.println(waishili);
h4.waiShiLiMethod();
Hello4.this.waiShiLiMethod();
waiShiLiMethod();
//3.对静态元素的访问，对象.静态元素,外部类类名.this.静态元素,外部类类名.静态元素,
//对象/外部类类名.this/外部类类名可以省略。
System.out.println(h4.waistatic);
System.out.println(Hello4.this.waistatic);
System.out.println(Hello4.waistatic);
System.out.println(waistatic);
h4.waiStaticMethod();
Hello4.this.waiStaticMethod();
Hello4.waiStaticMethod();
waiStaticMethod();
}
}
}
}1.对构造方法的访问，通过new 2.对实例元素的访问，只能对象访问
package com.wangxing.test1;
public class Hello5 {
public void shiliMethod(){
class World{
public String worldshili="方法内部类的实例变量";
public World(){
System.out.println("方法内部类的构造方法");
}
public void wordMethod1(){
System.out.println("方法内部类的实例方法");
}
}
//访问方法内部类中的构造方法，new
World w=new World();
//只能对象访问，实例变量和实例方法
System.out.println(w.worldshili);
w.wordMethod1();
}
}外部类中不能访问方法内部类中的元素，方法内部类就相当于是方法中的一个局部变量，
package com.wangxing.test1;
public class MyClass {
public void shiliMehtod(){
System.out.println("MyClass类的实例方法");
}
}
package com.wangxing.test1;
public class TestMain {
public static void main(String[] args) {
MyClass mc=new MyClass(){
public void shiliMehtod(){
System.out.println("MyClass类的实例方法111");
}
};
mc.shiliMehtod();
}
}那个java元素的{}中既可以定义变量，也可以定义方法？ java类中既可以定义变量，也可以定义方法 由此可知下面的代码是在创建一个java类
{
public String shili="实例变量";
public void shiliMehtod(){
System.out.println("MyClass类的实例方法111");
}
}只是没有具体的类名称，而且是写在了另一个类中，所以它是一个内部类 我们把它叫匿名内部类
给上面这个匿名内部类的前面添加了new MyClass()； 就变成类下面的情况。
new MyClass(){
public String shili="实例变量";
public void shiliMehtod(){
System.out.println("MyClass类的实例方法111");
}
}上面的代码是在创建匿名内部类的对象.创建出来的匿名内部类的对象就是MyClass类的子类对象 由此可知上面这个代码是在指明创建一个MyClass类的子类。
匿名内部类本质是一个子类
new MyClass(){
public String shili="实例变量";
//方法重写
public void shiliMehtod(){
System.out.println("MyClass类的实例方法111");
}
};
new--新建对象
MyClass()---MyClass类的子类
{
public String shili="实例变量";
//方法重写
public void shiliMehtod(){
System.out.println("MyClass类的实例方法111");
}
}---匿名内部类新建MyClass类的子类对象
匿名内部类本质是一个子类 优点:是减少类的创建 缺点:看不懂
就是给成员内部类上添加static修饰符
package com.wangxing.test1;
public class Hello {
public static class World{
}
}
静态内部类可以出现构造方法，实例元素，静态元素
package com.wangxing.test1;
public class Hello {
public static class World{
public String worldshili="静态内部类中的实例变量";
public static String worldstatic="静态内部类中的静态变量";
public World(){}
public void worldshiliMethod(){}
public static void worldstaticMethod(){}
}
}1.在静态内部类的构造方法和实例方法中可以访问静态内部类中构造方法，实例元素，静态元素 构造方法--new 实例元素--对象/this,可以省略 静态元素--对象/this/类名,可以省略 2.在静态内部类的静态方法中可以访问静态内部类中构造方法，实例元素，静态元素 构造方法--new 实例元素--对象 静态元素--对象/类名,可以省略 不能使用this
package com.wangxing.test1;
public class Hello1 {
public static class World1{
public String worldshili="静态内部类中的实例变量";
public static String worldstatic="静态内部类中的静态变量";
public World1(){}
public World1(String name){
World1 w11=new World1();
System.out.println(w11.worldshili);
System.out.println(this.worldshili);
System.out.println(worldshili);
w11.worldshiliMethod1();
this.worldshiliMethod1();
worldshiliMethod1();
System.out.println(w11.worldstatic);
System.out.println(this.worldstatic);
System.out.println(World1.worldstatic);
System.out.println(worldstatic);
w11.worldstaticMethod1();
this.worldstaticMethod1();
World1.worldstaticMethod1();
worldstaticMethod1();
}
public void worldshiliMethod1(){}
public void worldshiliMethod2(){
World1 w11=new World1();
System.out.println(w11.worldshili);
System.out.println(this.worldshili);
System.out.println(worldshili);
w11.worldshiliMethod1();
this.worldshiliMethod1();
worldshiliMethod1();
System.out.println(w11.worldstatic);
System.out.println(this.worldstatic);
System.out.println(World1.worldstatic);
System.out.println(worldstatic);
w11.worldstaticMethod1();
this.worldstaticMethod1();
World1.worldstaticMethod1();
worldstaticMethod1();
}
public static void worldstaticMethod1(){}
public static void worldstaticMethod2(){
World1 w11=new World1();
System.out.println(w11.worldshili);
//System.out.println(this.worldshili);
//System.out.println(worldshili);
w11.worldshiliMethod1();
//this.worldshiliMethod1();
//worldshiliMethod1();
System.out.println(w11.worldstatic);
//System.out.println(this.worldstatic);
System.out.println(World1.worldstatic);
System.out.println(worldstatic);
w11.worldstaticMethod1();
//this.worldstaticMethod1();
World1.worldstaticMethod1();
worldstaticMethod1();
}
}
}构造方法---new 实例元素---只能对象，不能省略 静态元素---对象/类名，可以省略
package com.wangxing.test1;
public class Hello2 {
public String helloshili="外部类中的实例变量";
public static String hellostatic="外部类中的静态变量";
public Hello2(){}
public void helloshiliMethod1(){}
public static void hellostaticMethod1(){}
public static class World2{
public World2(){
Hello2 h2=new Hello2();
System.out.println(h2.helloshili);
//System.out.println(Hello2.this.helloshili);
//System.out.println(helloshili);
h2.helloshiliMethod1();
//Hello2.this.helloshiliMethod1();
//helloshiliMethod1();
System.out.println(h2.hellostatic);
//System.out.println(Hello2.this.hellostatic);
System.out.println(Hello2.hellostatic);
System.out.println(hellostatic);
h2.hellostaticMethod1();
//Hello2.this.hellostaticMethod1();
Hello2.hellostaticMethod1();
hellostaticMethod1();
}
public void worldshiliMethod1(){
Hello2 h2=new Hello2();
System.out.println(h2.helloshili);
//System.out.println(Hello2.this.helloshili);
//System.out.println(helloshili);
h2.helloshiliMethod1();
//Hello2.this.helloshiliMethod1();
//helloshiliMethod1();
System.out.println(h2.hellostatic);
//System.out.println(Hello2.this.hellostatic);
System.out.println(Hello2.hellostatic);
System.out.println(hellostatic);
h2.hellostaticMethod1();
//Hello2.this.hellostaticMethod1();
Hello2.hellostaticMethod1();
hellostaticMethod1();
}
public static void worldstaticMethod1(){
Hello2 h2=new Hello2();
System.out.println(h2.helloshili);
//System.out.println(Hello2.this.helloshili);
//System.out.println(helloshili);
h2.helloshiliMethod1();
//Hello2.this.helloshiliMethod1();
//helloshiliMethod1();
System.out.println(h2.hellostatic);
//System.out.println(Hello2.this.hellostatic);
System.out.println(Hello2.hellostatic);
System.out.println(hellostatic);
h2.hellostaticMethod1();
//Hello2.this.hellostaticMethod1();
Hello2.hellostaticMethod1();
hellostaticMethod1();
}
}
}构造方法--new 实例元素--对象，不可以省略 静态元素--对象/类名，不可以省略
package com.wangxing.test1;
public class Hello3 {
public Hello3(){
World3 w33=new World3();
System.out.println(w33.worldshili);
w33.worldshiliMethod1();
System.out.println(w33.worldstatic);
System.out.println(World3.worldstatic);
w33.worldstaticMethod1();
World3.worldstaticMethod1();
}
public void helloshiliMethod1(){
World3 w33=new World3();
System.out.println(w33.worldshili);
w33.worldshiliMethod1();
System.out.println(w33.worldstatic);
System.out.println(World3.worldstatic);
w33.worldstaticMethod1();
World3.worldstaticMethod1();
}
public static void hellostaticMethod1(){
World3 w33=new World3();
System.out.println(w33.worldshili);
w33.worldshiliMethod1();
System.out.println(w33.worldstatic);
System.out.println(World3.worldstatic);
w33.worldstaticMethod1();
World3.worldstaticMethod1();
}
public static class World3{
public String worldshili="静态内部类中的实例变量";
public static String worldstatic="静态内部类中的静态变量";
public World3(){}
public void worldshiliMethod1(){}
public static void worldstaticMethod1(){}
}
}
1.没有导入静态内部类程序包的时候 构造方法--外部类类名.静态内部类类名 对象=new 外部类类名.静态内部类类名(); 实例元素--只能对象 静态元素--对象/外部类类名.静态内部类类名 2.有导入静态内部类程序包的时候 //import com.wangxing.test1.Hello.World; 构造方法--静态内部类类名 对象=new 外部类类名.静态内部类类名(); 实例元素--只能对象 静态元素--对象/外部类类名.静态内部类类名
package com.wangxing.test1;
public class Hello {
public static class World{
public String worldshili="静态内部类中的实例变量";
public static String worldstatic="静态内部类中的静态变量";
public World(){}
public void worldshiliMethod(){}
public static void worldstaticMethod(){}
}
}
package com.wangxing.test1;
import com.wangxing.test1.Hello.World;
public class Other {
public Other(){
Hello.World w=new Hello.World();
System.out.println(w.worldshili);
w.worldshiliMethod();
System.out.println(w.worldstatic);
System.out.println(Hello.World.worldstatic);
w.worldstaticMethod();
Hello.World.worldstaticMethod();
}
public void otherShili(){
//import com.wangxing.test1.Hello.World;
Hello.World w=new Hello.World();
//World w=new Hello.World();
System.out.println(w.worldshili);
w.worldshiliMethod();
System.out.println(w.worldstatic);
System.out.println(Hello.World.worldstatic);
w.worldstaticMethod();
Hello.World.worldstaticMethod();
}
public static void otherStatic(){
//import com.wangxing.test1.Hello.World;
//Hello.World w=new Hello.World();
World w=new Hello.World();
System.out.println(w.worldshili);
w.worldshiliMethod();
System.out.println(w.worldstatic);
System.out.println(Hello.World.worldstatic);
w.worldstaticMethod();
Hello.World.worldstaticMethod();
}
}