Java 内部类

Posted 2021-03-13 东功

1.非静态内部类

非静态内部类可以直接在一个类里面定义，实例化非静态内部类时必须建立在一个外部类实例化的基础上

语法：new 外部类().new 内部类();

非静态内部类可以访问外部类的private实例属性

 1 public class Hero {
 2     private String name; // 姓名
 3  
 4     float hp; // 血量
 5  
 6     float armor; // 护甲
 7  
 8     int moveSpeed; // 移动速度
 9  
10     // 非静态内部类，只有一个外部类对象存在的时候，才有意义
11     // 战斗成绩只有在一个英雄对象存在的时候才有意义
12     class BattleScore {
13         int kill;
14         int die;
15         int assit;
16  
17         public void legendary() {
18             if (kill >= 8)
19                 System.out.println(name + "超神！");
20             else
21                 System.out.println(name + "尚未超神！");
22         }
23     }
24  
25     public static void main(String[] args) {
26         Hero garen = new Hero();
27         garen.name = "盖伦";
28         // 实例化内部类
29         // BattleScore对象只有在一个英雄对象存在的时候才有意义
30         // 所以其实例化必须建立在一个外部类对象的基础之上
31         BattleScore score = garen.new BattleScore();
32         score.kill = 9;
33         score.legendary();
34     }
35  
36 }

2.静态内部类

静态内部类实例化的时候不需要外部类实例化作为前提

语法：new 外部类.内部类();

因为没有外部类的实例，所以在静态内部类里面没法访问外部类实例的属性和方法

除了能访问外部类的静态私有属性外，和普通类没什么区别

 1 public class Hero {
 2     public String name;
 3     protected float hp;
 4   
 5     private static void battleWin(){
 6         System.out.println("battle win");
 7     }
 8      
 9     //敌方的水晶
10     static class EnemyCrystal{
11         int hp=5000;
12          
13         //如果水晶的血量为0，则宣布胜利
14         public void checkIfVictory(){
15             if(hp==0){
16                 Hero.battleWin();
17                  
18                 //静态内部类不能直接访问外部类的对象属性
19                 System.out.println(name + " win this game");
20             }
21         }
22     }
23      
24     public static void main(String[] args) {
25         //实例化静态内部类
26         Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
27         crystal.checkIfVictory();
28     }
29   
30 }

3.匿名类

是指在声明一个类的同时实例化，使代码更加简洁，要使用一个接口或者抽象类，都必须创建一个子类

有时候为了快速使用，就直接实例化抽象类，并“当场”实现抽象类中的方法

public abstract class Hero {
    String name; //姓名
          
    float hp; //血量
          
    float armor; //护甲
          
    int moveSpeed; //移动速度
      
    public abstract void attack();
      
    public static void main(String[] args) {
          
        Hero h = new Hero(){
            //当场实现attack方法
            public void attack() {
                System.out.println("新的进攻手段");
            }
        };
        h.attack();
       
    }
      
}

 输出

新的进攻手段

 

 4.本地类

本地类可以理解为有名字的匿名类，可以声明在方法体，for循环中

 1 public abstract class Hero {
 2     String name; //姓名
 3           
 4     float hp; //血量
 5           
 6     float armor; //护甲
 7           
 8     int moveSpeed; //移动速度
 9       
10     public abstract void attack();
11       
12     public static void main(String[] args) {
13           
14         //与匿名类的区别在于，本地类有了自定义的类名
15         class SomeHero extends Hero{
16             public void attack() {
17                 System.out.println( name+ " 新的进攻手段");
18             }
19         }
20          
21         SomeHero h  =new SomeHero();
22         h.name ="地卜师";
23         h.attack();
24     }
25       
26 }