JAVA -- 接口与继承（十）内部类

阳光穿透心脏的1/2处 2022-12-08 15:36 248阅读 0赞

内部类分为四种：  
非静态内部类  
静态内部类  
匿名类  
本地类

## 非静态内部类 ##

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

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

package 学习;
    
    
    public class test {
        
    	String name;
    	public test(String name) {
        
    		this.name = name;
    	}
    	
    	class Battlescore{
        
    		int kill;
    		int die;
    		int assit;
    		public void legendary() {
        
    			if(kill>7)
    			System.out.println(name + "超神了");
    			else
    				System.out.println("还没有超神呢");
    		}
    	}
    	
    	public static void main(String args[]) {
        
    		test a = new test("诺克萨斯之手");
    		Battlescore b = a.new Battlescore();
    		b.kill = 9;
    		b.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();
        }
      
    }

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

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

public abstract class test {
        
    	String name;
    	public abstract void utter();
    	public static void main(String args[]) {
        
    		test a = new test() {
        
    			public void utter() {
        
    				System.out.println("当场实现一个方法");
    			}
    		};
    		a.utter();
    	}
    }

## 本地类 ##

本地类可以理解为有名字的匿名类  
内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。  
本地类和匿名类一样，直接声明在代码块里面，可以是主方法，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

## 练习-内部类⭐⭐ ##

public abstract class item {
        
    	String name;
    	int price;
    
    	public abstract void disposiable();
    	public static void main(String args[]) {
        
    		item a = new item() {
        
    			public void disposiable() {
        
    				System.out.println("我叫做可以任意处理的");
    			}
    		};
    		a.disposiable();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE3ODAyODk1_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE3ODAyODk1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/533b6c9dbb954a38a2f09d739259c3eb.png