java基础中的--------内部类

内部类

1.概述

1.定义在类的内部的类，就是内部类，可以定义在方法的内 部，也可以定义在类的内部。
2.根据定义的位置不同，可以分为：
成员内部类
局部内部类
3.成员内部类
普通的成员内部类
私有的成员内部类
静态的成员内部类
4.根据表示的方式不同，可以分为
有名字的内部类
匿名内部类 【常用】

2.普通的成员内部类

1.定义在成员位置上的类，就是成员内部类
2.定义格式：
class 类名｛｝
3.成员内部类的说明：
内部类可以直接访问外部类的所有成员，包括私有成员。
外部类访问内部类的成员，必须先创建内部类的对象
在外部其它类中，创建内部类的对象的格式
外部类名.内部类名 对象名 = new 外部类名().new 内部类名()

//外部其它类
public class Demo01 {

	public static void main(String[] args) {
		/*Body b = new Body();
		b.test();*/
		Body.Heart h = new Body().new Heart();
		h.show();

	}

}
//外部类
class Body{
	private double weight = 60;
	
	//成员内部类
	class Heart{
		int beats = 80;
		
		public void show() {
			System.out.println("扑通扑通地跳，一分钟跳动"+beats+"次"+",体重为"+weight);
		}
		
	}
	
	public void test() {
		Heart h = new Heart();
		h.show();
	}
}

3.私有的成员内部类

1.也是一个成员内部类，在成员内部类前面加一个private关键字
2.访问方式说明：
在外部类以外，不能直接访问外部类中的私有成员变量
可以在外部类中，定义一个访问私有成员内部类的公有方法，让外界可以调用公有方法，间接地调用外部类中的私有成员内部类

public class Demo02 {

	public static void main(String[] args) {
		Body b = new Body();
		b.test();

	}

}
class Body{
	private double height = 170;
	//私有成员内部类
	private class Shen{
		int age = 20;
		public void show() {
			System.out.println("您的肾的年龄为"+age+"..."+height);
		}
		
		
	}
	
	public void test() {
		Shen shen = new Shen();
		shen.show();
		
	}
	
}

4.静态的成员内部类

1.也是一个成员内部类，在成员内部类前加一个static关键字
2.访问特点：
1.静态成员内部类的对象创建格式：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
2.一个类是否需要创建对象，不取决于该类是否为静态，而取决于要访问的成员是否是静态
3.静态成员内部类的非静态对象，需要将所在的内部类对象创建出来之后，才能被调用
4.静态成员内部类要访问外部类的非静态成员时，要么设置为静态，要么创建外部类对象，调用其成员
5.成员内部类是外部类的静态成员，所以可以通过类名直接调用，而不需要创建外部类的对象

public class Demo03 {

	public static void main(String[] args) {
		/*Body.Lung l = new Body.Lung();
		l.show();*/
		//Body.Lung.show();
		
		System.out.println(Body.Lung.color);

	}

}
class Body{
	private double height = 170.5;
	//静态成员内部类
	static class Lung{
		static String color = "black";
		public void show() {
			Body b = new Body();		
			System.out.println("肺的颜色为："+color+"...."+b.height);
		}
		
	}
}

5.局部内部类

1.局部内部类：定义在方法中的内部类
2.局部内部类的访问说明：
方法中的局部变量，外界都没有办法访问到，所以方法中定义的内部类，外界也没有办法访问
3.解决方式
在方法内部，就创建局部内部类的对象，调用对象的方法
外界调用局部内部类所在的方法，间接地创建局内部类的对象，间接地访问局部内部类的方法

public class Demo04 {

	public static void main(String[] args) {
		breath();

	}
	
	public static void breath() {
		int f = 100;
		//局部内部类
		class Fei{
			String color = "black";
			public void show() {
				System.out.println(f+"...."+color);
			}
			
		}
		Fei fei = new Fei();
		fei.show();
		
	}

}

6.匿名内部类

1.没有名字的内部类
2.前提：要么继承一个类要么实现一个接口
3.格式：
new 父类类名或者接口名(){
父类的方法的重写或者接口内容的实现
}
4.本质：创建了一个类的子类对象，接口的实现类对象。
5.内部类的名称总结
如果是有名字的内部类，类名【外部类名$内部类名】
如果没有名字的内部类，通过匿名内部类的顺序描述类名，第一外匿名内部名称【外部类名$1】,第二个匿名内部类名【外部类名$2】

public class Demo05 {

	public static void main(String[] args) {
		/*InterImpl ii = new InterImpl();
		ii.method();*/
		//多态
		Inter inter = new Inter() {
			@Override
			public void method() {
				System.out.println("method invoke...");			
			}

			@Override
			public void run() {
				System.out.println("run invoke...");
				
			}		
		};
		inter.method();
		inter.run();
		/*new Inter() {
			@Override
			public void method() {
				System.out.println("method invoke...");			
			}

			@Override
			public void run() {
				System.out.println("run invoke...");
				
			}		
		}.run();*/
		
		
		

	}

}

interface Inter{
	
	void method();
	void run();
	
	
}
/*class InterImpl implements Inter{

	@Override
	public void method() {
		System.out.println("method invoke...");
		
	}
	
}*/
public class Demo06 {

	public static void main(String[] args) {
		MyInter mi = new MyInter() {

			@Override
			public void method() {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void run() {
				// TODO Auto-generated method stub
				
			}
			
		};
		
		mi.method();
		mi.run();

	}

}
interface MyInter{
	void method();
	void run();
	
	
}

自己搞的 脑路图 转载要说一下哦