内部类:
在一个类的内部定义的类称为内部类。
类的内部：
第一：与属性或方法 同级
内部类
这个类与外部类的每个对象是一对一的关系。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);
}
}
