为什么要北京PK10平台出租（www.1159880099.com）QQ1159880099 使用内部类：
使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
内部类：顾名思义就是把类放在某个范围里
类可以放在包中
类可以放在文件夹中
类可以放在类中 //内部类
类可以放在方法中 //内部类
一、成员内部类
类中放置内部类，类里套类，类中类
要使用内部类，就需要在外部类中实例化内部类的对象，然后通过对象打点调用内部类中的方法，通过方法操作内部类数据。
内部类可以直接使用外部类的属性和方法，就像孙悟空钻进铁扇公主肚子里。
复制代码
1 public class OuterClass {
2 //外部类中的属性
3 private int outer_1=100; //私有属性
4 public int outer_2=10; //公有属性
5
6 //外部类方法outer_method1
7 public void outer_method1(){
8 System.out.println("outer_method1");
9 InnerClass ic=new InnerClass();
10 //调用内部类中的方法
11 ic.inner_method1();
12 //调用内部类中的私有属性和公有属性
13 System.out.println(ic.inner_1+" "+ic.inner_2);
14 }
15
16 //有名的内部类InnerClass
17 class InnerClass{
18 //内部类中的属性
19 private int inner_1=123; //私有属性
20 public int inner_2=321; //公有属性
21 //内部类方法inner_method1
22 public void inner_method1(){
23 //调用外部类中的方法，
24 outer_method1();
25 //调用外部类中的私有属性和公有属性
26 System.out.println(outer_1+" "+outer_2);
27 }
28 }
29 }
复制代码
二、局部内部类
方法中中放置内部类
要使用方法中的内部类，就必须在方法中，内部类定义的下面实例化内部类的对象，然后通过内部类对象打点调用内部类的方法，
内部类的作用域仅限于当前方法，对内部类定义开始到方法结束，作用域消失。
在内部类中可以直接使用外部类中的当前方法中的局部变量，在方法的外面不能使用方法中的内部类。
复制代码
1 /*
2 方法中放置内部类
3 */
4 public class OuterClass {
5 //外部类中的属性
6 private int outer_1=100; //私有属性
7 public int outer_2=10; //公有属性
8 //外部类中的方法
9 public void outer_method1(){
10 System.out.println("outer_method1()");
11 System.out.println("outer_1"+"outer_2");
12
13 //方法中的内部类
14 class InnerClass{
15 //内部类中的属性
16 private int inner_1=123; //私有属性
17 public int inner_2=321; //公有属性
18 //内部类中的公有方法
19 public void inner_method1(){
20 System.out.println("public method1");
21 System.out.println(outer_1);
22 }
23 //内部类中的私有 方法
24 private void inner_method2(){
25 System.out.println("private method2");
26 System.out.println(outer_1+" "+outer_2);
27 } }
28 //实例化内部类
29 InnerClass ic=new InnerClass();
30 ic.inner_method1();
31 ic.inner_method2();
32 System.out.println(ic.inner_1+" "+ic.inner_2);
33 //作用域到此处结束
34 }
35 }
复制代码
三、匿名内部类
- 匿名内部类是没有访问修饰符的。
2.有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。
3.匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。
4.当前匿名内部类中实现的方法，只能实现一次，如果还想其他的实现，必须用匿名内部类重新new实现。
复制代码
1 public class Demo {
2 public void TetMethod1(){
3 //匿名内部类 new 的是CommonPerson的子实现，但没有类名，把子实现的对象赋值给长辈引用
4 CommonPerson cp=new CommonPerson(){
5 @Override
6 public void study() {
7 }
8 @Override
9 public void eat() {
10 }
11 };
12 }
13 public static void main(String[] args) {
14 //有名内部类
15 class Student implements IPerson{
16 public void study(){}
17 public void eat(){}
18 }
19 Student stu1=new Student();
20 IPerson ip=stu1;
21
22 //匿名内部类
23 IPerson ip1=new IPerson(){
24 public void study(){}
25 public void eat() {}
26 };
27 IPerson ip2=new IPerson(){
28 public void study(){}
29 public void eat() {}
30 };
31 }
32 }
33
34
35 public interface IPerson { //定义的接口IPerson
36
37 public void study();
38 public void eat();
39 }
复制代码
四、嵌套内部类
嵌套内部类分为静态内部类和非静态内部类
1.静态内部类
1、 它的创建不需要依赖于外部类。
2、 它不能使用任何外围类的非static成员变量和方法。
2.非静态内部类
1.它的创建需要依赖于外部类 。
2.在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，可以随便调用外部类中的成员，不管是静态的还是非静态的，相当霸道。
复制代码
1 public class OuterClass {
2 private String sex;
3 public static String name = "ma";
4 /
5 静态内部类
6 /
7 static class InnerClass1{
8 / 在静态内部类中可以存在静态成员 /
9 public static String name1 = "1_static";
10 public void display(){
11 //静态内部类只能访问外围类的静态成员变量和方法
12 System.out.println("OuterClass name :" + name);
13 } }
14 /
15 非静态内部类
16 /
17 class InnerClass2{
18 / 非静态内部类中不能存在静态成员 /
19 public String name2 = "2_inner";
20 / 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的,这就有点霸道了/
21 public void display(){
22 System.out.println("OuterClass name：" + name);
23 }
24 }
25 public void display(){
26 // 外部类访问静态内部类
27 System.out.println(InnerClass1.name1);
28 new InnerClass1().display();
29 / 非静态内部的创建需要依赖于外部类 /
30 OuterClass.InnerClass2 inner2=new OuterClass().new InnerClass2();
31 System.out.println(inner2.name2);
32 inner2.display();
33 }
34 }