Java 内部类 的详细概述

内部类概述
    .就是在类中定义一个类，
    .举例：在有类A中定义一个B,类B就被成为内部类
内部类的分类
    .成员内部类
    .局部内部类
    .匿名内部类
    .静态内部类
内部类的定义格式
    .格式
        public class 类名{
             修饰符 class 类名{
             }
        }
    .范例
        public class Outer{
             public class Innter{
             }
        }
    .内部类的访问特点
       内部类可以直接访问外部类的成员，包括私有
       外部类想要访问内部类的成员，必须创建对象
成员内部类
    .在类的成员位置：成员内部类
    .在类的局部位置：局部内部类  ->也就是在方法内部的
    
成员内部类，外界（大小外部）如何创建对象使用呢？
    (不常用的，我们设置个内部类的目的就是不想让你们知道，所以类名用private修饰会更好一些。
    再在外部类里面存放一个方法获取内部类的值，在大外部类调用的时候，只需要调取外部类的方法即可)
    .格式
       外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    .范例
       outer.inner oi = new outer().new inner();
局部内部类
    .局部内部类在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用
    .该类可以直接访问外部类的成员，也可以访问方法内的局部变量
匿名内部类（局部内部类的一种特殊形式）
    .前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类->如果是类的话，抽象类居多
    .格式
        new 类名或者接口名(){
           重写方法;
       };
    .范例
        new inter(){
            public void show(){
            }
        };
    .本质
       是一个继承了该类或者实现了该接口的子类匿名对象
       .其本质应该是可以在方法里面写对象和关于对象的东西，然后进行输出，其好处是不用再到处创建类了，方便，

以下分为四个案例

1.内部类

2.成员内部类

3.局部内部类

4.匿名内部类

5.匿名内部类在开发中的使用

1.内部类

package 内部类;

public class Outer {
	
	private int num =10;
	
	
	
	public class Innter{
		
		private void show() {
			// TODO 自动生成的方法存根
			System.out.println(num);

		}
		
    }
	
	public void method() {
		// TODO 自动生成的方法存根
		Innter i = new Innter();
		i.show();
}
	

}

2.成员内部类（分为innerdemo类 和 outer类）

innerdemo类

package 成员内部类;

public class innerdemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//创建内部类的对象，并调用方法
//		outer.inner oi = new outer().new inner();//内部类的常用访问方法，方便但是不安全
//		oi.show();
		outer o = new outer ();
		o.method();

	}

}

outer类

package 成员内部类;

public class outer {
	
	//成员变量
	private int num  =10;
	
	//成员内部类
//	public class inner {
//		// TODO 自动生成的方法存根
//		public void show() {
//			// TODO 自动生成的方法存根
//			System.out.println(num);
//
//		}
//
//	}
	private class inner {
		
		public void show() {
			System.out.println(num);
		}
		
	}
    public void method() {
		// TODO 自动生成的方法存根
    	inner i = new inner();
    	i.show();

	}

}

3.局部内部类（分为outerdemo类 和 outer类）

outerdemo类

package 局部内部类;

public class outerdemo {
	
	/*
局部内部类
    .局部内部类在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用
    .该类可以直接访问外部类的成员，也可以访问方法内的局部变量
	 */

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		outer o =new outer();
		o.method();
		

	}

}

outer类

package 局部内部类;

public class outer {
	private int num =19;
	
	
	public void method() {
		int num=100;
		
		class inner{
			public void show() {
				// TODO 自动生成的方法存根
				System.out.println(num);

			}
			
		}
		inner i = new inner();
		i.show();

	}

}

4.匿名内部类（分为outerdemo类 和 outer类 和inter接口类）

outerdemo类

package 匿名内部类;

public class outerdemo {
	/*
匿名内部类（局部内部类的一种特殊形式）
    .前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类->如果是类的话，抽象类居多
    .格式
        new 类名或者接口名(){
           重写方法;
       };
    .范例
        new inter(){
            public void show(){
            }
        };
    .本质
       是一个继承了该类或者实现了该接口的子类匿名对象
	*/
	public static void main(String[] args) {
		
		outer o = new outer();
		o.method();
		
	}
	

}

outer类

package 匿名内部类;

public class outer {
	
	public void method() {
		 
		/*
		 new inter() {

			@Override
			public void show() {
				// TODO 自动生成的方法存根
				
			}

		};*/
//		 new inter() {
//
//				@Override
//				public void show() {
//					// TODO 自动生成的方法存根
//					System.out.println("内部匿名类");
//				}
//}.show();


//多次复用的方式
		
		inter i = new inter() {

				@Override
				public void show() {
					// TODO 自动生成的方法存根
					System.out.println("内部匿名类");
				}
};
                i.show();




	}

}

inter接口类

package 匿名内部类;

public interface inter {
	
	void show();

}

5.匿名内部类在开发中的使用（分为jumpingOperator类，jumping接口类，cat类，dog类，jumpingdemo类）

jumpingOperator类

package 匿名内部类在开发中的使用;

public class jumpingOperator {
	
	public void method(jumping j) {
		// TODO 自动生成的方法存根
		j.jump();

	}	

}

jumping接口类

package 匿名内部类在开发中的使用;

public interface jumping {
	void jump();

}

cat类

package 匿名内部类在开发中的使用;

public class cat implements jumping {

	@Override
	public void jump() {
		// TODO 自动生成的方法存根
		System.out.println("猫可以跳18米了");
		
	}

}

dog类

package 匿名内部类在开发中的使用;

public class dog implements jumping {

	@Override
	public void jump() {
		// TODO 自动生成的方法存根
		System.out.println("狗可以跳30米");
		
	}

}

jumpingdemo类

package 匿名内部类在开发中的使用;

public class jumpingdemo {
	
	public static void main(String[] args) {
		jumpingOperator jo = new jumpingOperator();
		jumping j = new cat();
		jo.method(j);
		
		jumping j2 = new dog();
		jo.method(j2);
		
		
		System.out.println("---------------------------------------");
		
		jo.method(new jumping() {

			@Override
			public void jump() {
				// TODO 自动生成的方法存根
				System.out.println("猫可以跳一万米了");
				
			}
			
		});
	}

}