Java——内部类

Java——内部类

内部类
类中定义类
当一个类中的成员也是一个事物,并且需要使用这个事物的多个相关内容,这时候,把它定义成内部类

内部类的分类:
1.成员内部类
2.局部内部类
3.静态内部类
4.私有内部类
5.匿名内部类

内部类实例

成员内部类:

定义在外部类的成员位置
成员内部类具有成员的特点,也具有类的特点
可以使用成员修饰符修饰,可以实现类的继承,接口的实现...
成员修饰符只能修饰成员,不能修饰局部,public...static..final(能够修饰局部..)

注意: 成员内部类中 不可以定义静态内容,除了静态常量

public class InnerClassDemo01 {
		int a=5;			//成员变量
		private int b=10;		//私有成员变量
		static int c=15;			//静态变量
		int i =100;				//外部类的成员变量i
	
		final class Inner{				//成员内部类
			String name="张三";
			static final int AGE=14;
			int i =1000;		//内部类的成员变量i
			
			void testInner() {
				System.out.println("成员内部类的成员方法");
				//测试成员内部类中 是否 可以使用外部类中内容 包括私有内容都可以使用
				System.out.println(a);
				System.out.println(b);
				System.out.println(c);
			}
		
			void testI() {
				int i =10000;		//局部变量i
				System.out.println(InnerClassDemo01.this.i);		//外部类的成员变量i	
				System.out.println(this.i);	//内部类的成员变量i
				System.out.println(i);		//局部变量i
			}
	}

		void outer() {	//成员方法
			System.out.println("外部类的成员方法");
			//测试外部类中是否可以使用内部类中的内容 :通过内部类对象使用
			Inner in = new Inner();
			System.out.println(in.name);
			in.testInner();
		}
	
	}

public class Yeil{
	
	public static void main(String[] args) {
		Join01.Inner j = new Join01().new Inner();
		j.testInner();
		j.testI();
		Join01 j1 = new Join01();
		j1.outer();
	}
}

静态内部类:

• 可以定义静态内容
• 在静态内部类中使用外部类中的内容,静态的都可以直接使用,成员的都要跟随对象使用,因为内部类的静态的
• 在外部类中使用过静态内部类中的内容,静态内容通过雷名使用,成员内容通过对象使用
• 其他类中使用静态内部类的内容,如果是静态内容,通过外部类名.内部类名.静态内容
• 如果是成员内容,通过外new 外部类名.内部类名().成员内容

public class StaticInnerClass02 {
	private int a=5;
	static int b=10;
	
	//静态内部类
	static class Inner{
		int c=15;
		static int d=20;
		
		static void testStatic() {
			System.out.println("静态内部类中的静态方法");
			//测试在静态内部类中的静态方法中使用外部类中的内容:可以直接使用静态内容,通过对象使用成员内容
			System.out.println(b);
			System.out.println(new StaticInnerClass02().a);
		}
		
		void test() {
			System.out.println("静态内部类中的成员方法");
			//测试在静态内部类中的成员方法中使用外部类中的内容:可以直接使用静态内容,通过对象使用成员内容
			System.out.println(b);
			System.out.println(new StaticInnerClass02().a);
		}
	}
	
	//外部类成员方法
	void outer() {
		System.out.println("外部类成员方法");
		//测试使用静态内部类中的静态内容
		System.out.println(Inner.d);
		Inner.testStatic();
		//测试使用静态内部类中的成员内容
		Inner in=new Inner();
		in.test();
	}
}

私有内部类

• 只能在当前外部类通过对象使用,其他类无法使用

public class PrivateInnerClass03 {
		private int a=5;
		static int b=10;
	
			//私有内部类
		private class Inner{
			private int c=15;
		
			void inner() {
				System.out.println("私有内部类中的成员方法");
				System.out.println(a);
				System.out.println(b);
			}
		
		
			void outer() {
				System.out.println("外部类的成员方法");
				Inner in=new Inner();
				System.out.println(in.c);
			}
		}
}	

局部内部类

• 定义在局部 位置(方法…)
• 局部内部类不能使用private…static修饰,但是final可以
• 只能在当前所在的方法中使用,其他类,外部 类中无法使用
• 如果在局部内部类中使用方法的参数,默认这个参数被final关键字修饰,没有用,就没有默认

public class LocalInnerClass04 {
		int i=1;	
		void test(String args) {
		int a=5; //局部变量
		
		//args="";
		
		//局部内部类
		class Inner{
			int b=10;
			
			void inner() {
				System.out.println(b);
				System.out.println(a);
				System.out.println(i);
				System.out.println(args);
			}
		}
		//测试方法中是否可以使用局部内部类中的内容:可以通过局部内部类对象使用
		System.out.println(new Inner().b);
		}
		
		//外部类的成员方法
		void outer() {
			//测试外部类中是否可以使用局部内容类中的内容 :无法使用
			//System.out.println(new Inner().b);
		}
	}

匿名内部类:

当实现类没有本身作用,只是为了重写接口中抽象方法的,可以选择使用匿名内部类

public class AnonymousInnerClass05 {
			public static void main(String[] args) {
			//Swim demo = new Demo();
			//匿名内部类的使用1 :直接调用,只能当前使用一次,因为没有引用指向,没有存储 对象地址
			//new 的是swim接口的没有名字的实现类的对象
			new Swim(){//实现类的类体|匿名内部类的雷体
			  
			@Override 
			public void swimming() { 
			System.out.println("自游泳..."); 
			}

			@Override
			public void sleep() {
				// TODO Auto-generated method stub
				
			}
			  
		}.swimming();
		
		//匿名内部类的使用2 :有引用指向
		Swim s = new Swim() { //接口多态

			@Override
			public void swimming() {
				System.out.println("狗刨");
			}

			@Override
			public void sleep() {
				System.out.println("水里休息");
			}
			
		};
		
		
		s.swimming();
		s.sleep();
		
		//匿名内部类的使用3 :方法的参数
		test(new Swim() {

			@Override
			public void swimming() {
				System.out.println("仰泳");
			}

			@Override
			public void sleep() {
				System.out.println("水中芭蕾");
			}
			
		});
		}
		
		
		static void test(Swim s) {
			s.swimming();
			s.sleep();
		}
	}

下一篇，抽象类