内部类：
在一个类里面还有一个类，Outer外部类、Inner内部类
内部类的访问规则：
内部类可以直接访问外部类中的成员、包括私有。
能够访问的原因是：内部类中持有一个外部类的引用。
格式：外部类名.this
外部类要访问内部类、必须建议内部类对象。
当内部类定义在外部类的成员位置上时，并且非私有，可以在外部其他类中访问，格式为：
外部类名.内部类名 变量名 = 外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();
内部类可以放在成员位置上，既然是成员就可以被成员修饰符修饰。
private：将内部类在外部类中进行封装。
static：修饰后内部类就具有静态的特性。
当内部类被static修饰后，在内部类中只能访问外部类中的静态，出现了访问限制。
在外部其他类中，如何访问静态内部类额非静态成员呢？
new Outer.Inner().show();
在外部其他类中，如何访问静态内部类中的静态成员？
Outer.Inner.show();
代码示例
class Demo{// 外部其他类
public static void main(String[] args){
/*
Outer out = new Outer();
out.show();*/
/*
Outer.Inner in = new Outer().new Inner();// 格式
in.method();*/
//Outer.Inner inner = new Outer.Inner(); inner.method(); 等价于下面的
new Outer.Inner().method();
Outer.Inner.methodA();
}
}
class Outer{// 外部类
private int num = 10;
private static int price = 100;
public void show(){
/*
System.out.println(this.num);
Inner in = new Inner();
in.method();
*/
}
/*private*/ static class Inner{// 内部类
public void method(){
price = 300;
System.out.println(price);
}
public static void methodA(){
System.out.println(price+1000);
}
}
}
注意：
1. 当内部类中定义了静态成员、那么该内部类必须是静态的。
2. 当外部类中的静态方法访问内部类时、内部类也必须是静态的。
代码示例
class Demo1{// 外部其他类
public static void main(String[] args){
}
}
class Outer{// 外部类
private int num = 10;
private static int price = 100;
public static void show(){
new Inner().method();
}
static class Inner{// 内部类
public void method(){
System.out.println(price);
}
}
}
内部类定义原则：
当描述事物时，事物的内部还有事物，该事物用内部类来描述，这样的设计更优秀，因为内部事物在使用外部事物的内部。
如：人体和心脏，心脏应该使用私有修饰，并提供方法供外界访问。
代码示例
class Demo2{// 外部其他类
public static void main(String[] args){
Body body = new Body();
body.broken();
body.treat("doctor");
}
}
class Body{// 外部类
private int hand = 2;
private int foot = 2;
private int finger = 10;
public void broken(){
new Heart().broken();
}
public void treat(String work){
if(work.equals("doctor")){
new Heart().jump();
}
System.out.println("滚犊子。。。");
}
private class Heart{// 内部类
String leftHeartRoom = "左心室";
String leftHeart = "左心房";
String rightHeart = "右心房";
int num = 0;
public void jump(){
while(true){
if(num==10){
num=0;
}
System.out.println("boom..."+num);
num++;
try{
Thread.sleep(500);
}catch(Exception e){
System.out.println("---");
}
}
}
public void broken(){
System.out.println("伤了一下下");
}
}
}
匿名内部类： 没有名字的内部类
- 匿名内部类的格式：
new 父类或者接口(){
//定义子类的内容
} - 定义匿名内部类的前提：
内部类必须继承一个类或者实现一个接口。 - 从代码上直观的看其实匿名内部类就是一个匿名子类对象。该对象带了一对大括号，可以理解为带内容的对象。
4.开发中匿名内部类使用场景： 继承抽象类 或者实现接口 、重写抽象类的抽象方法或重写接口中的所有抽象方法。
代码示例
/*
abstract class Animal{
public abstract void eat();
public abstract void work();
public abstract void sleep();
}*/
interface Animal{
Animal eat();
}
class Person{
/*
private Person(){
}*/
public void eat(){
}
}
class Demo3{
public static void main(String[] args){
/*
Animal a1 = new Animal(){
public void eat(){
System.out.println("吃啊吃 咋不撑死你。。。");
}
public void work(){
System.out.println("工作啊工作 你能不能懂点生活。。。");
}
public void sleep(){
System.out.println("赶紧洗洗睡吧");
}
};
a1.eat();
a1.work();
a1.sleep();*/
/*
new Animal(){
public void eat(){
System.out.println("吃啊吃 咋不撑死你。。。111");
}
public void work(){
System.out.println("工作啊工作 你能不能懂点生活。。。");
}
public void sleep(){
System.out.println("赶紧洗洗睡吧");
}
}.eat();
*/
/*
new Animal(){
public Animal eat(){
System.out.println("吃啊吃 吃了一只老虎 吐出来");
return this;
}
}.eat().eat().eat();// 链式调用 开发中不要这么干
*/
new Person(){
};
System.out.println(
new Object(){
public int hashCode(){
return 1314;
}
public String toString(){
return "520";
}
}.toString());
}
}
