JAVA 内部类 inner class

内部类:
在一个类的内部定义的类称为内部类。
类的内部：
第一：与属性或方法同级
内部类
这个类与外部类的每个对象是一对一的关系。Person与Birthday
静态内部类
这个类与外部类是1对1的关系。每个对象共享这个内部类对象。Hero和Crystal
第二：在方法内部
本地内部类
在方法中定义的类（局部类，出了方法就没了）
匿名内部类
没名字，与抽象类和接口配合使用。创建内部类的同时创建对象。

使用频次：
匿名类：非常频繁
静态内部类：单例，系统的部分类（Map.Entry<K,V>）
内部类：Birthday和Person
本地内部类：几乎不用

//一个文件（xx.java）里面可以定义若干个类。
//定义类的语法格式：
// class 类名{属性和方法}
//每个类定义完以后，都能正常的使用。
//和你在每一个单独定义一个类差不多。

//如果一个文件里定义了多个类。那么这个文件中只能有一个public修饰的类.
//因为编译器会做检查，public修饰的类必须与文件名相同。
//因为文件名只有一个，所以你只能把其中一个类声明为public

//没有用public修饰的类与public修饰的类到底什么区别呢？
//唯一的区别就是类的作用范围不同，public修饰的类，可以跨包使用
//没有public修饰的类，不能跨包使用，只能在本包中使用。

//什么是内部类呢？
//在一个类的内部定义的类称为内部类。

//什么情况下需要使用内部类呢？
//如果一个类(Birthday)是为了另外一个类(Person)而存在的，
//那么这个类(Birthday)可以定义为另外一个类(Person)的内部类.

//怎么使用内部类？
//内部类如何创建对象
//外部类.内部类对象名 = 外部类对象.new 内部类(参数)
//内部类如何使用呢？—访问属性，访问方法
//正常访问对象名.属性对象名.方法

//我们见过哪个系统内部类呢？
//Map.Entry<K,V>

class MyClass{
class InnerClass1{
    public InnerClass1() {
        System.out.println("InnerClass1 created..");
    }
}
class InnerClass2{
    public InnerClass2() {
        System.out.println("InnerClass2 created..");
    }
}
void getInnerClass() {
    new InnerClass1();
    new InnerClass2();
}
public static void main(String[] args) {
    new MyClass().getInnerClass();
}
}

//输出：
InnerClass1 created…

InnerClass2 created…

//在一个类的方法内部定义的类，称为本地（局部）内部类。

public class LocalClass {

public static void main(String[] args) {

	class A{
		int a;
		int b;
		
		public int getA() {
			return a;
		}

		public void setA(int a) {
			this.a = a;
		}

		public int getB() {
			return b;
		}

		public void setB(int b) {
			this.b = b;
		}

		public void test() {
			System.out.println("本地类的方法");
		}
	}
	
	A a = new A();
	a.setA(100);
	System.out.println(a.getA());
	a.test();
	
}
}

//匿名内部类，它是一个没有名字的本地内部类。
//为什么时候匿名内部类是本地内部类？
//因为匿名内部类是出现在方法里的。

//因为匿名内部类没有名字，因此匿名内部类不能像其他类一样
//正常的创建对象。
//因此我们创建匿名内部类的同时把对象创建出来。
//抽象类对象 = new 抽象类(参数){
// 实现抽象类中的抽象方法（有几个实现几个）
//};
//
//接口名对象 = new 接口名(){
// 实现接口中的全部方法
//};

//与匿名内部类配套使用的是抽象和接口。

public class NoNameClass {

public static void main(String[] args) {

	
	A a1 = new B();
	a1.test();
	
	int x = 100;
	
	A a2 = new A() {
		@Override
		public void test() {
			int y = x + 20;
			System.out.println("haha"+x);
			aaa();
		}
		
		public void aaa() {
			System.out.println("hello world");
		}
		
	};
	a2.test();
	A a3 = new A() {
		@Override
		public void test() {
			System.out.println("这是匿名类的使用");
		}
	};
	a3.test();
	
	
	MyInterface c = new C();
	c.test();
	
	MyInterface c2 = new MyInterface() {
		@Override
		public void test() {
			System.out.println("我是接口的匿名实现类");
		}
	};
	c2.test();
}
}

//什么是静态内部类，在一个类内部定义的用static修饰的类叫静态内部类
//静态内部类与内部类的区别是什么？
//内部类是属于每个对象的，每个对象都有一个。
//静态内部类是属于类的，大家共享一个。
//如何创建静态内部类的对象呢?
//外部类.静态内部类对象名 = new 外部类.静态内部类(参数)
//如何访问静态内部类呢？----访问属性，访问方法
//正常访问对象名.属性对象名.方法

//什么时候用过静态内部类呢？
//----单例的第三种写法

public class Test2 {

public static void main(String[] args) throws Exception {
	Hero h1 = new Hero("提莫",1000,200);
	Hero h2 = new Hero("盖伦",1500,180);

	
	
	Hero.Crystal crystal = new Hero.Crystal();
	crystal.test();
	
	Class c = crystal.getClass();
	Field hp = c.getDeclaredField("hp");
	hp.setAccessible(true);
	hp.set(crystal, 10000);
	System.out.println(crystal);

}
}

JAVA 内部类 inner class

猜你喜欢