Java内部类重温

39次阅读

共计 3474 个字符,预计需要花费 9 分钟才能阅读完成。

还记得上大学那会,在编程课上总听到老师说“累不累”,我也很纳闷,什么“累不累”,我上课也不累啊 ^_^!,后来看书原来说的是“内部类”这个概念,现在想想也真搞笑。

一、什么是内部类

在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。

内部类分为四种:

  • 非静态内部类
  • 静态内部类
  • 匿名类
  • 本地类

二、非静态内部类

非静态内部类 BattleScore“战斗成绩”
非静态内部类可以直接在一个类里面定义

比如:
战斗成绩只有在一个英雄对象存在的时候才有意义
所以实例化 BattleScore 的时候,必须建立在一个存在的英雄的基础上
语法: new 外部类 ().new 内部类()
作为 Hero 的非静态内部类,是可以直接访问外部类的 private 实例属性 name 的

package charactor;
 
public class Hero {
    private String name; // 姓名
 
    float hp; // 血量
 
    float armor; // 护甲
 
    int moveSpeed; // 移动速度
 
    // 非静态内部类,只有一个外部类对象存在的时候,才有意义
    // 战斗成绩只有在一个英雄对象存在的时候才有意义
    class BattleScore {
        int kill;
        int die;
        int assit;
 
        public void legendary() {if (kill >= 8)
                System.out.println(name + "超神!");
            else
                System.out.println(name + "尚未超神!");
        }
    }
 
    public static void main(String[] args) {Hero garen = new Hero();
        garen.name = "盖伦";
        // 实例化内部类
        // BattleScore 对象只有在一个英雄对象存在的时候才有意义
        // 所以其实例化必须建立在一个外部类对象的基础之上
        BattleScore score = garen.new BattleScore();
        score.kill = 9;
        score.legendary();}
 
}

三、静态内部类

在一个类里面声明一个静态内部类
比如敌方水晶,当敌方水晶没有血的时候,己方所有英雄都取得胜利,而不只是某一个具体的英雄取得胜利。
与非静态内部类不同,静态内部类 水晶类的实例化 不需要一个外部类的实例为基础,可以直接实例化
语法:new 外部类. 静态内部类 ();
因为没有一个外部类的实例,所以在静态内部类里面不可以访问外部类的实例属性和方法
除了可以访问外部类的 私有静态成员外,静态内部类和普通类没什么大的区别。

package charactor;
  
public class Hero {
    public String name;
    protected float hp;
  
    private static void battleWin(){System.out.println("battle win");
    }
     
    // 敌方的水晶
    static class EnemyCrystal{
        int hp=5000;
         
        // 如果水晶的血量为 0,则宣布胜利
        public void checkIfVictory(){if(hp==0){Hero.battleWin();
                 
                // 静态内部类不能直接访问外部类的对象属性
                System.out.println(name + "win this game");
            }
        }
    }
     
    public static void main(String[] args) {
        // 实例化静态内部类
        Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
        crystal.checkIfVictory();}
  
}

四、匿名内

匿名类指的是在 声明一个类的同时实例化它 ,使代码更加简洁精练
通常情况下,要使用一个接口或者抽象类,都必须创建一个子类

有的时候,为了快速使用,直接实例化一个抽象类,并“当场 ”实现其抽象方法。
既然实现了抽象方法,那么就是一个新的类,只是这个类,没有命名。
这样的类,叫做匿名类

package charactor;
   
public abstract class Hero {
    String name; // 姓名
          
    float hp; // 血量
          
    float armor; // 护甲
          
    int moveSpeed; // 移动速度
      
    public abstract void attack();
      
    public static void main(String[] args) {ADHero adh=new ADHero();
        // 通过打印 adh,可以看到 adh 这个对象属于 ADHero 类
        adh.attack();
        System.out.println(adh);
          
        Hero h = new Hero(){
            // 当场实现 attack 方法
            public void attack() {System.out.println("新的进攻手段");
            }
        };
        h.attack();
        // 通过打印 h,可以看到 h 这个对象属于 Hero$1 这么一个系统自动分配的类名
          
        System.out.println(h);
    }
      
}

五、本地类

本地类可以理解为有名字的匿名类
内部类与匿名类不一样的是,内部类必须声明在成员的位置,即与属性和方法平等的位置。
本地类和匿名类一样,直接声明在代码块里面,可以是主方法,for 循环里等等地方

package charactor;
   
public abstract class Hero {
    String name; // 姓名
          
    float hp; // 血量
          
    float armor; // 护甲
          
    int moveSpeed; // 移动速度
      
    public abstract void attack();
      
    public static void main(String[] args) {
          
        // 与匿名类的区别在于,本地类有了自定义的类名
        class SomeHero extends Hero{public void attack() {System.out.println( name+ "新的进攻手段");
            }
        }
         
        SomeHero h  =new SomeHero();
        h.name ="地卜师";
        h.attack();}
      
}

六、在匿名类中使用外部的局部变量

在匿名类中使用外部的局部变量,外部的局部变量必须修饰为 final

为什么要声明为 final,其机制比较复杂,请参考第二个 Hero 代码中的解释

注:在 jdk8 中,已经不需要强制修饰成 final 了,如果没有写 final,不会报错,因为编译器偷偷的帮你加上了看不见的 final

Hero.java

package charactor;
   
public abstract class Hero {public abstract void attack();
      
    public static void main(String[] args) {
 
        // 在匿名类中使用外部的局部变量,外部的局部变量必须修饰为 final
        final int damage = 5;
         
        Hero h = new Hero(){public void attack() {System.out.printf("新的进攻手段,造成 %d 点伤害",damage);
            }
        };
 
    }
      
}

Hero.java

package charactor;
   
public abstract class Hero {public abstract void attack();
      
    public static void main(String[] args) {
 
        // 在匿名类中使用外部的局部变量 damage 必须修饰为 final
        int damage = 5;
         
        // 这里使用本地类 AnonymousHero 来模拟匿名类的隐藏属性机制
         
        // 事实上的匿名类,会在匿名类里声明一个 damage 属性,并且使用构造方法初始化该属性的值
        // 在 attack 中使用的 damage,真正使用的是这个内部 damage,而非外部 damage
         
        // 假设外部属性不需要声明为 final
        // 那么在 attack 中修改 damage 的值,就会被暗示为修改了外部变量 damage 的值
         
        // 但是他们俩是不同的变量,是不可能修改外部变量 damage 的
        // 所以为了避免产生误导,外部的 damage 必须声明为 final,"看上去" 就不能修改了
        class AnonymousHero extends Hero{
            int damage;
            public AnonymousHero(int damage){this.damage = damage;}
            public void attack() {
                damage = 10;
                System.out.printf("新的进攻手段,造成 %d 点伤害",this.damage);
            }
        }
         
        Hero h = new AnonymousHero(damage);
         
    }
      
}

相关文章:
Java 内部类详解
Java 内部类 How2J.cn 教程

正文完
 0