(六)final、权限、内部类、引用类型

最新推荐文章于 2022-11-28 11:43:34 发布
最新推荐文章于 2022-11-28 11:43:34 发布
阅读量109 收藏
点赞数
分类专栏： JavaEE学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/j572864517/article/details/104987517
版权

第一章 final关键字

1.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final关键字， 用于修饰不可改变内容。

  • final： 不可改变。可以用于修饰类、方法和变量。
    • 类：被修饰的类，不能被继承。
    • 方法：被修饰的方法，不能被重写。
    • 变量：被修饰的变量，不能被重新赋值。

1.2 使用方式

修饰类

格式如下：
final class 类名 { }
查询API发现像public final class String、 public final class Math 、 public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

格式如下：

修饰符 final 返回值类型 方法名(参数列表){     
      //方法体
 }

重写被 final 修饰的方法，编译时就会报错。

修饰变量

  1. 局部变量——基本类型
    基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {     
  public static void main(String[] args) {         
    // 声明变量，使用final修饰         
    final int a;         
    // 第一次赋值          
    a = 10;         
    // 第二次赋值        
     a = 20; // 报错,不可重新赋值             
    
    // 声明变量，直接赋值，使用final修饰         
    final int b = 10;         
    // 第二次赋值         
    b = 20; // 报错,不可重新赋值     
  } 
}
  1. 局部变量——引用类型
    引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：
public class FinalDemo2 {     
  public static void main(String[] args) {         
    // 创建 User 对象         
    final User u = new User();         
    // 创建 另一个 User对象         
    u = new User(); // 报错，指向了新的对象，地址值改变。           
    
    // 调用setName方法         
    u.setName("张三"); // 可以修改     
  } 
}
  1. 成员变量
    成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
  • 显示初始化；
public class User {     
  final String USERNAME = "张三";     
  private int age; 
}
  • 构造方法初始化。
public class User {     
  final String USERNAME ;     
  private int age;     
  public User(String username, int age) {         
    this.USERNAME = username;         
    this.age = age;     
  } 
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

第二章 权限修饰符

2.1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

  • public：公共的
  • protected：受保护的
  • default：默认的
  • private：私有的

2.2 不同权限的访问能力

publicprotecteddefault（空的）private
同一类中√√√√
同一包中(子类与无关类)√√√
不同包的子类√√
不同包中的无关类√

可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：

  • 成员变量使用 private ，隐藏细节。
  • 构造方法使用 public ，方便创建对象。
  • 成员方法使用 public ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

第三章 内部类

3.1 概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

  • 成员内部类 ：定义在类中方法外的类。
    定义格式：
class 外部类 {     
  class 内部类{       

  } 
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类Car中包含发动机类Engine，这时，Engine就可以使用内部类来描述，定义在成员位置。

访问特点

  • 内部类可以直接访问外部类的成员，包括私有成员。
  • 外部类要访问内部类的成员，必须要建立内部类的对象。
    创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

访问演示，代码如下：
定义类：

public class Person {     
  private  boolean live = true;     
  class Heart {         
    public void jump() {             
      // 直接访问外部类成员             
      if (live) {                 
        System.out.println("心脏在跳动");             
      } else {                 
        System.out.println("心脏不跳了");             
      }         
    }     
  }       
  public boolean isLive() {         
    return live;     
  }       
  public void setLive(boolean live) {         
    this.live = live;     
  }   
}

定义测试类：

public class InnerDemo {
  public static void main(String[] args) {         
    // 创建外部类对象          
    Person p  = new Person();         
    // 创建内部类对象         
    Heart heart = p.new Heart();           
    // 调用内部类方法         
    heart.jump();         
    // 调用外部类方法         
    p.setLive(false);         
    // 调用内部类方法         
    heart.jump();    
 } 
} 

输出结果: 
心脏在跳动 
心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和 符 号 。 比 如 ， P e r s o n 符号。 比如，Person 符号。比如，PersonHeart.class

3.2 匿名内部类【重点】

  • 匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。
    开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，
  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法
    我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提

匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名(){     
  // 方法重写     
  @Override      
  public void method() {         
    // 执行语句     
  } 
};

使用方式
以接口为例，匿名内部类的使用，代码如下：
定义接口：

public abstract class FlyAble{     
  public abstract void fly(); 
}

创建匿名内部类，并调用：

public class InnerDemo {     
  public static void main(String[] args) {         
    /*         
    1.等号右边:是匿名内部类，定义并创建该接口的子类对象         
    2.等号左边:是多态赋值,接口类型引用指向子类对象         
    */         
    FlyAble  f = new FlyAble(){             
      public void fly() {                 
        System.out.println("我飞了~~~");             
      }         
    };          
     
    //调用 fly方法,执行重写后的方法         
    f.fly();     
  } 
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

public class InnerDemo2 {     
  public static void main(String[] args) {         
    /*         
    1.等号右边:定义并创建该接口的子类对象         
    2.等号左边:是多态,接口类型引用指向子类对象        
    */         
    FlyAble  f = new FlyAble(){             
      public void fly() {                 
        System.out.println("我飞了~~~");             
      }         
    };         
    
    // 将f传递给showFly方法中         
    showFly(f);     
  }     

  public static void showFly(FlyAble f) {         
      f.fly();     
  } 
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {     
  public static void main(String[] args) {                       
      /*         
      创建匿名内部类,直接传递给showFly(FlyAble f)           
      */         
      showFly( new FlyAble(){             
        public void fly() {                 
          System.out.println("我飞了~~~");            
        }         
      });     
    }       

  public static void showFly(FlyAble f) {         
      f.fly();     
  } 
}

第四章 引用类型用法总结

实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。

4.1 class作为成员变量

在定义一个类Role（游戏角色）时，代码如下：

class Role {    
  int id; // 角色id       
  int blood; // 生命值       
  String name; // 角色名称    
}

使用int类型表示 角色id和生命值，使用String类型表示姓名。此时，String本身就是引用类型，由于使用 的方式类似常量，所以往往忽略了它是引用类型的存在。如果我们继续丰富这个类的定义，给Role增加武器，穿戴装备等属性，我们将如何编写呢？
定义武器类，将增加攻击能力：

class Weapon {   
  String name； // 武器名称         
  int hurt； // 伤害值  
  }

定义穿戴盔甲类，将增加防御能力，也就是提升生命值：

class Armour {    
  String name；// 装备名称        
  int protect；// 防御值   
  }

定义角色类：

class Role {     
  int id；     
  int blood；     
  String name；     
  // 添加武器属性     
  Weapon wp；     
  // 添加盔甲属性     
  Armour ar；       
  // 提供get/set方法     
  public Weapon getWp() {         
    return wp;     
  }     
  public void setWeapon(Weapon wp) {         
    this.wp = wp;     
  }     
  public Armour getArmour() {        
     return ar;     
  }     
  public void setArmour(Armour ar) {         
    this.ar = ar;     
  }       
  
  // 攻击方法     
  public void attack(){         
    System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害");       
  }       
  // 穿戴盔甲     
  public void wear(){         
    // 增加防御,就是增加blood值         
    this.blood += ar.getProtect();         
    System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());     
  }   
}

测试类：

public class Test {    
  public static void main(String[] args) {         
    // 创建Weapon 对象              
    Weapon wp = new Weapon("屠龙刀" , 999999);                 
    // 创建Armour 对象           
    Armour ar = new Armour("麒麟甲",10000);           
    // 创建Role 对象           
    Role r = new Role();                          
    // 设置武器属性           
    r.setWeapon(wp);    
    // 设置盔甲属性               
    r.setArmour(ar);
    // 攻击
    r.attack();            
    // 穿戴盔甲       
     r.wear();       
   } 
} 

输出结果: 
使用屠龙刀,造成999999点伤害 
穿上麒麟甲 ,生命值增加10000

类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。

4.2 interface作为成员变量

接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。所以，如果想扩展更强大技能，我们在 Role 中，可以增加接口作为成员变量，来设置不同的技能。
定义接口：

// 法术攻击 
public interface FaShuSkill {     
  public abstract void faShuAttack(); 
}

定义角色类：

public class Role {     
  FaShuSkill fs;       
  public void setFaShuSkill(FaShuSkill fs) {         
    this.fs = fs;     
    }     
    // 法术攻击      
    public void faShuSkillAttack(){         
      System.out.print("发动法术攻击:");         
      fs.faShuAttack();         
      System.out.println("攻击完毕");     
  } 
}

定义测试类：

public class Test {     
  public static void main(String[] args) {         
    // 创建游戏角色         
    Role role = new Role();         
    // 设置角色法术技能         
    role.setFaShuSkill(new FaShuSkill() {
      @Override
      public void faShuAttack() {                 
        System.out.println("纵横天下");            
      }         
    });           
    
    // 发动法术攻击         
    role.faShuSkillAttack();           
    // 更换技能         
    role.setFaShuSkill(new FaShuSkill() {             
      @Override             
      public void faShuAttack() {                 
        System.out.println("逆转乾坤");             
      }         
    });         
    // 发动法术攻击         
    role.faShuSkillAttack(); 
  }      
} 

输出结果: 
发动法术攻击:纵横天下 
攻击完毕   

发动法术攻击:逆转乾坤 
攻击完毕

我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

4.3 interface作为方法参数和返回值类型

当接口作为方法的参数时,需要传递什么呢？当接口作为方法的返回值类型时，需要返回什么呢？对，其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所 以，当我们看见 List 接口作为参数或者返回值类型时，当然可以将 ArrayList 的对象进行传递或返回。
请观察如下方法：获取某集合中所有的偶数。
定义方法：

public static List<Integer> getEvenNum(List<Integer> list) {     
  // 创建保存偶数的集合     
  ArrayList<Integer> evenList = new ArrayList<>();     
  // 遍历集合list,判断元素为偶数,就添加到evenList中     
  for (int i = 0; i < list.size(); i++) {         
    Integer integer = list.get(i);         
    if (integer % 2 == 0) {             
      evenList.add(integer);         
    }     
  }     
  /*      
  返回偶数集合       
  因为getEvenNum方法的返回值类型是List,
  而ArrayList是List的子类
  所以evenList可以返回
  */       
  return evenList; 
}

调用方法：

public class Test {     
  public static void main(String[] args) {         
    // 创建ArrayList集合,并添加数字         
    ArrayList<Integer> srcList = new ArrayList<>();         
    for (int i = 0; i < 10; i++) {             
      srcList.add(i);         
    }           
    /*         
    获取偶数集合           
    因为getEvenNum方法的参数是List,
    而ArrayList是List的子类,           
    所以srcList可以传递           
    */            
    List list = getEvenNum(srcList);         
    System.out.println(list);     
  } 
}

接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。 # final、权限、内部类、引用类型

第一章 final关键字

1.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final关键字， 用于修饰不可改变内容。

  • final： 不可改变。可以用于修饰类、方法和变量。
    • 类：被修饰的类，不能被继承。
    • 方法：被修饰的方法，不能被重写。
    • 变量：被修饰的变量，不能被重新赋值。

1.2 使用方式

修饰类

格式如下：
final class 类名 { }
查询API发现像public final class String、 public final class Math 、 public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

格式如下：

修饰符 final 返回值类型 方法名(参数列表){     
      //方法体
 }

重写被 final 修饰的方法，编译时就会报错。

修饰变量

  1. 局部变量——基本类型
    基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {     
  public static void main(String[] args) {         
    // 声明变量，使用final修饰         
    final int a;         
    // 第一次赋值          
    a = 10;         
    // 第二次赋值        
     a = 20; // 报错,不可重新赋值             
    
    // 声明变量，直接赋值，使用final修饰         
    final int b = 10;         
    // 第二次赋值         
    b = 20; // 报错,不可重新赋值     
  } 
}
  1. 局部变量——引用类型
    引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：
public class FinalDemo2 {     
  public static void main(String[] args) {         
    // 创建 User 对象         
    final User u = new User();         
    // 创建 另一个 User对象         
    u = new User(); // 报错，指向了新的对象，地址值改变。           
    
    // 调用setName方法         
    u.setName("张三"); // 可以修改     
  } 
}
  1. 成员变量
    成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
  • 显示初始化；
public class User {     
  final String USERNAME = "张三";     
  private int age; 
}
  • 构造方法初始化。
public class User {     
  final String USERNAME ;     
  private int age;     
  public User(String username, int age) {         
    this.USERNAME = username;         
    this.age = age;     
  } 
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

第二章 权限修饰符

2.1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

  • public：公共的
  • protected：受保护的
  • default：默认的
  • private：私有的

2.2 不同权限的访问能力

publicprotecteddefault（空的）private
同一类中√√√√
同一包中(子类与无关类)√√√
不同包的子类√√
不同包中的无关类√

可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：

  • 成员变量使用 private ，隐藏细节。
  • 构造方法使用 public ，方便创建对象。
  • 成员方法使用 public ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

第三章 内部类

3.1 概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

  • 成员内部类 ：定义在类中方法外的类。
    定义格式：
class 外部类 {     
  class 内部类{       

  } 
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类Car中包含发动机类Engine，这时，Engine就可以使用内部类来描述，定义在成员位置。

访问特点

  • 内部类可以直接访问外部类的成员，包括私有成员。
  • 外部类要访问内部类的成员，必须要建立内部类的对象。
    创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

访问演示，代码如下：
定义类：

public class Person {     
  private  boolean live = true;     
  class Heart {         
    public void jump() {             
      // 直接访问外部类成员             
      if (live) {                 
        System.out.println("心脏在跳动");             
      } else {                 
        System.out.println("心脏不跳了");             
      }         
    }     
  }       
  public boolean isLive() {         
    return live;     
  }       
  public void setLive(boolean live) {         
    this.live = live;     
  }   
}

定义测试类：

public class InnerDemo {
  public static void main(String[] args) {         
    // 创建外部类对象          
    Person p  = new Person();         
    // 创建内部类对象         
    Heart heart = p.new Heart();           
    // 调用内部类方法         
    heart.jump();         
    // 调用外部类方法         
    p.setLive(false);         
    // 调用内部类方法         
    heart.jump();    
 } 
} 

输出结果: 
心脏在跳动 
心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和 符 号 。 比 如 ， P e r s o n 符号。 比如，Person 符号。比如，PersonHeart.class

3.2 匿名内部类【重点】

  • 匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。
    开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，
  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法
    我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提

匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名(){     
  // 方法重写     
  @Override      
  public void method() {         
    // 执行语句     
  } 
};

使用方式
以接口为例，匿名内部类的使用，代码如下：
定义接口：

public abstract class FlyAble{     
  public abstract void fly(); 
}

创建匿名内部类，并调用：

public class InnerDemo {     
  public static void main(String[] args) {         
    /*         
    1.等号右边:是匿名内部类，定义并创建该接口的子类对象         
    2.等号左边:是多态赋值,接口类型引用指向子类对象         
    */         
    FlyAble  f = new FlyAble(){             
      public void fly() {                 
        System.out.println("我飞了~~~");             
      }         
    };          
     
    //调用 fly方法,执行重写后的方法         
    f.fly();     
  } 
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

public class InnerDemo2 {     
  public static void main(String[] args) {         
    /*         
    1.等号右边:定义并创建该接口的子类对象         
    2.等号左边:是多态,接口类型引用指向子类对象        
    */         
    FlyAble  f = new FlyAble(){             
      public void fly() {                 
        System.out.println("我飞了~~~");             
      }         
    };         
    
    // 将f传递给showFly方法中         
    showFly(f);     
  }     

  public static void showFly(FlyAble f) {         
      f.fly();     
  } 
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {     
  public static void main(String[] args) {                       
      /*         
      创建匿名内部类,直接传递给showFly(FlyAble f)           
      */         
      showFly( new FlyAble(){             
        public void fly() {                 
          System.out.println("我飞了~~~");            
        }         
      });     
    }       

  public static void showFly(FlyAble f) {         
      f.fly();     
  } 
}

第四章 引用类型用法总结

实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。

4.1 class作为成员变量

在定义一个类Role（游戏角色）时，代码如下：

class Role {    
  int id; // 角色id       
  int blood; // 生命值       
  String name; // 角色名称    
}

使用int类型表示 角色id和生命值，使用String类型表示姓名。此时，String本身就是引用类型，由于使用 的方式类似常量，所以往往忽略了它是引用类型的存在。如果我们继续丰富这个类的定义，给Role增加武器，穿戴装备等属性，我们将如何编写呢？
定义武器类，将增加攻击能力：

class Weapon {   
  String name； // 武器名称         
  int hurt； // 伤害值  
  }

定义穿戴盔甲类，将增加防御能力，也就是提升生命值：

class Armour {    
  String name；// 装备名称        
  int protect；// 防御值   
  }

定义角色类：

class Role {     
  int id；     
  int blood；     
  String name；     
  // 添加武器属性     
  Weapon wp；     
  // 添加盔甲属性     
  Armour ar；       
  // 提供get/set方法     
  public Weapon getWp() {         
    return wp;     
  }     
  public void setWeapon(Weapon wp) {         
    this.wp = wp;     
  }     
  public Armour getArmour() {        
     return ar;     
  }     
  public void setArmour(Armour ar) {         
    this.ar = ar;     
  }       
  
  // 攻击方法     
  public void attack(){         
    System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害");       
  }       
  // 穿戴盔甲     
  public void wear(){         
    // 增加防御,就是增加blood值         
    this.blood += ar.getProtect();         
    System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());     
  }   
}

测试类：

public class Test {    
  public static void main(String[] args) {         
    // 创建Weapon 对象              
    Weapon wp = new Weapon("屠龙刀" , 999999);                 
    // 创建Armour 对象           
    Armour ar = new Armour("麒麟甲",10000);           
    // 创建Role 对象           
    Role r = new Role();                          
    // 设置武器属性           
    r.setWeapon(wp);    
    // 设置盔甲属性               
    r.setArmour(ar);
    // 攻击
    r.attack();            
    // 穿戴盔甲       
     r.wear();       
   } 
} 

输出结果: 
使用屠龙刀,造成999999点伤害 
穿上麒麟甲 ,生命值增加10000

类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。

4.2 interface作为成员变量

接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。所以，如果想扩展更强大技能，我们在 Role 中，可以增加接口作为成员变量，来设置不同的技能。
定义接口：

// 法术攻击 
public interface FaShuSkill {     
  public abstract void faShuAttack(); 
}

定义角色类：

public class Role {     
  FaShuSkill fs;       
  public void setFaShuSkill(FaShuSkill fs) {         
    this.fs = fs;     
    }     
    // 法术攻击      
    public void faShuSkillAttack(){         
      System.out.print("发动法术攻击:");         
      fs.faShuAttack();         
      System.out.println("攻击完毕");     
  } 
}

定义测试类：

public class Test {     
  public static void main(String[] args) {         
    // 创建游戏角色         
    Role role = new Role();         
    // 设置角色法术技能         
    role.setFaShuSkill(new FaShuSkill() {
      @Override
      public void faShuAttack() {                 
        System.out.println("纵横天下");            
      }         
    });           
    
    // 发动法术攻击         
    role.faShuSkillAttack();           
    // 更换技能         
    role.setFaShuSkill(new FaShuSkill() {             
      @Override             
      public void faShuAttack() {                 
        System.out.println("逆转乾坤");             
      }         
    });         
    // 发动法术攻击         
    role.faShuSkillAttack(); 
  }      
} 

输出结果: 
发动法术攻击:纵横天下 
攻击完毕   

发动法术攻击:逆转乾坤 
攻击完毕

我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

4.3 interface作为方法参数和返回值类型

当接口作为方法的参数时,需要传递什么呢？当接口作为方法的返回值类型时，需要返回什么呢？对，其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所 以，当我们看见 List 接口作为参数或者返回值类型时，当然可以将 ArrayList 的对象进行传递或返回。
请观察如下方法：获取某集合中所有的偶数。
定义方法：

public static List<Integer> getEvenNum(List<Integer> list) {     
  // 创建保存偶数的集合     
  ArrayList<Integer> evenList = new ArrayList<>();     
  // 遍历集合list,判断元素为偶数,就添加到evenList中     
  for (int i = 0; i < list.size(); i++) {         
    Integer integer = list.get(i);         
    if (integer % 2 == 0) {             
      evenList.add(integer);         
    }     
  }     
  /*      
  返回偶数集合       
  因为getEvenNum方法的返回值类型是List,
  而ArrayList是List的子类
  所以evenList可以返回
  */       
  return evenList; 
}

调用方法：

public class Test {     
  public static void main(String[] args) {         
    // 创建ArrayList集合,并添加数字         
    ArrayList<Integer> srcList = new ArrayList<>();         
    for (int i = 0; i < 10; i++) {             
      srcList.add(i);         
    }           
    /*         
    获取偶数集合           
    因为getEvenNum方法的参数是List,
    而ArrayList是List的子类,           
    所以srcList可以传递           
    */            
    List list = getEvenNum(srcList);         
    System.out.println(list);     
  } 
}

接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。

Code-Coke
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础【final、权限、内部类、引用类型】
12-21
day11【final、权限、内部类、引用类型】第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法修饰变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类3.1 概述什么是内部类成员内部类访问特点3.2 ...
H264文档：Single NAL Unit Packet
10-19
H264文档：Single NAL Unit Packet，是一个很不错的H264文档教程，有兴趣的伙伴们抽时间可以看一下把。
final 关键字总结
Peanut的博客
03-19 173
final关键字主要用在三个地方： 变量、方法、类。 1 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改； 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。 2 当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。 3.使用final方法的原因有两个。 第一个原因是把方法锁定，以防任何继承类修...
final、权限、内部类、引用类型
weixin_40055163的博客
08-29 206
final、权限、内部类、引用类型 1 final关键字 1.1 概述 学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。 final： 不可改变。可以用于修饰类、方法和变量。 类：被修饰的类，不能被继承。 方法：被修饰的方法，不能被重写。 变量：被修饰的变量，不能被重新赋值。 1.2 使用方式 修饰类 格式如下： final
详解：final修饰的变量 是引用变量不能变 还是引用变量指向的对象的内容不能变
weixin_42652696的博客
03-20 1873
直接上代码： /** * 问： 使用final关键字 修饰一个变量时，是指引用变量不能变，还是指引用变量所指向的对象的内容不能变？ * * 答： 使用final关键字 修饰一个变量是，是指引用变量不能变，引用变量所指向的对象的内容是可以变的。 * * 验证思路： * 在java中每一个对象都有自己独一无二的哈希编码，根据这个编码就可以找到对应的对象。 * 因此，根据哈...
final修饰变量，只是引用不可变，不关心指向对象内容的变化
皮卡丘的博客
08-26 536
【final变量的变与不变】： 一般都说final变量在赋值后就不可变， 这个不变指的是引用，是地址，而所引用的对象的内容仍然是可变的。
Java基础知识回顾- final 关键字
随时记
08-01 217
final关键字主要用在三个地方：变量、方法、类。 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的 变量，则在对其初始化之后便不能再让其指向另一个对象。 当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第...
Java基础final、权限、内部类、引用类型
kai46385076的专栏
07-05 258
今日内容 final关键字 权限 内部类 引用类型 教学目标 描述final修饰的类的特点 描述final修饰的方法的特点 能够说出权限修饰符作用范围 说出内部类的概念 能够理解引用类型作为成员变量 能够理解引用类型作为方法参数 能够理解引用类型作为方法返回值类型 第一章 final关键字 1.1概述 学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承AP...
final、权限、内部类、引用类型的介绍
Xingye_01的博客
11-28 53
查询API发现像public final class String、public final class Math、public final class Scanner等，都是被final修饰的，目前就是供我们使用，而不让我们随意改变其内容。关于static关键字的使用，它可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单属于某个对象的。2.1 概述：在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。//报错，指向了新的对象，地址值改变。
H.264 NAL Unit 教程
10-05
关于 H.264 中 NAL 单元格式的详细解析，主要是 Header 的结构和 Type 列表
NAL层解析（C语言）
01-06
主要用来H.264的NAL头，区分NAL单元是属于那种分类，里面包含测试文件，代码是从标准H.264解码的代码中提出来的
H264 MP NAL
12-10
一段H264视频采集后数据，保存文件，供学习H264编码使用
minepy-1.2.6-cp310-cp310-win_amd64.zip
06-17
使用说明：whl是python离线安装包，使用时候只需要pip install x.whl其中x.whl为自己whl路径名
恒色风格-中医简历模板.zip
06-17
在求职的征途上，一份出色的简历是你通往梦想职位的敲门砖。我们精心准备了一系列面试求职简历模板，旨在帮助你以最佳形象站在潜在雇主面前。这些简历模板不仅设计精美，而且注重内容的清晰呈现，使招聘经理一目了然地看到你的能力和经验。 我们的模板集合了多种风格与布局，无论你是应届毕业生、职场跳槽者还是行业专家，都能在这里找到适合你职业形象的简历设计。每一个模板都经过精心设计，确保你的简历在众多求职者中脱颖而出，同时保持足够的专业度和可读性。 不仅如此，我们的简历模板易于编辑，你可以根据具体职位需求快速调整内容，展现你的个人优势和职业成就。使用这些模板，将大大提高你的面试机会，并帮助你更好地表达自己的价值和潜力。 别让传统且缺乏创意的简历阻碍你迈向成功的道路。立即下载这些精美的简历模板，让你的求职之路更加顺畅，向心仪的工作迈进吧！记住，一个良好的开始是成功的一半，而一份精致的简历，正是你成功的起点。
protobuf-3.15.1-cp36-cp36m-macosx_10_9_x86_64.whl
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
pyzmq-23.2.0-cp37-cp37m-win_amd64.whl
最新发布
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
hevc流中解析nal header,slice类型 代码实现
05-23
代码中使用了 ifstream 类来打开 HEVC 流文件，然后读取数据并解析 NAL 头和切片类型。NAL 头包含了 forbidden_zero_bit、nal_unit_type、nuh_layer_id 和 nuh_temporal_id_plus1 等字段。切片类型用枚举类型 Slice...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值