JavaSE从头再来（二）
从头再来第二弹，关于继承与多态，全文大概1w字，花了接近9个小时才码完
四、继承与多态
case1 继承
面向对象的三大特征：封装、继承、多态。
继承是多态的前提，没有继承，就没有多态。
由来
继承主要解决的问题就是：共性抽取，提高代码的复用性
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要
继承那一个类即可 。
其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。
继承描述的是事物之间的所属关系，这种关系是：is-a的关系。
定义
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接
访问父类中的非私有的属性和行为。
继承格式
关键字：extends，可以声明一个子类继承另外一个父类
class 父类{
...
}
class 子类 extends 父类{
...
}
成员变量
-
成员变量不重名 ：如果子类父类中出现不重名的成员变量，这时的访问是没有影响的
-
成员变量重名 ：子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用
super关键字，修饰父类成员变量，类似于 this- 使用格式
super.父类成员变量名
- 使用格式
成员方法
-
成员方法不重名 ：如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法
-
成员方法重名：如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(Override)，即子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
- 重写的应用：子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强，
super.父类方法名表示调用父类的成员方法
class Phone {
public void sendMessage(){
System.out.println("发短信");
}
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("来电显示号码");
}
}
//智能手机类
class NewPhone extends Phone {
//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
public void showNum(){
//调用父类已经存在的功能使用super
super.showNum();
//增加自己特有显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
}
- 注意事项
- 子类方法覆盖父类方法，必须要保证权限大于等于父类权限 （青出于蓝）
- 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样
构造方法，super()
- 构造方法的名字是与类名一致的。所以子类无法继承父类构造方法的
- 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个
super（），表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用
class Fu{
private int n;
Fu(){
System.out.println("父类初始化成功");
}
}
class Zi extends Fu{
Zi(){
//super(),调用父类的构造方法
super();
System.out.println("子类初始化成功");
}
}
Zi zi = new Zi();
输出结果
父类初始化成功
子类初始化成功
super和this
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下：
- super：代表父类的存储空间标识，理解为父类的引用
- this：代表当前对象的引用（谁调用就代表谁）
用法
- 访问成员
- this.成员变量 / 成员方法 – 本类的
- super.成员变量 / 成员方法 – 父类的
class Animal{
public void eat(){
System.out.println("animal:eat");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("cat:eat");
}
public void eatTest(){
//this 调用本类的方法
this.eat();
//super 调用父类的方法
super.eat();
}
}
Animal a = new Animal();
a.eat();
Cat c = new Cat();
c.eatTest();
输出结果：
animal:eat
cat:eat
animal:eat
- 访问构造方法
- this(…) – 本类的构造方法
- super(…) – 父类的构造方法
子类的每个构造方法中均有默认的super（）调用父类的空参构造。手动调用父类构造会覆盖默认的super（）。super（）和this（）都必须是在构造方法的第一行，所以不能同时出现。
Java的单继承
Java只支持单继承，不支持多继承 ：一个类只能有一个父类，不可以有多个父类。
class C extends A{} //OK
class C extends A,B... //ERROR
Java支持多层继承(继承体系) ：顶层父类是Object类。所有的类默认继承Object，作为父类
class A{}
class B extends A{}
class C extends B{}
子类和父类是一种相对的概念
case2 抽象类
概述
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法
定义
- **抽象方法：**没有方法体的方法
- **抽象类：**包含抽象方法的类
abstract使用格式
抽象方法
使用 abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
定义格式：
修饰符 abstract 返回值类型 方法名（参数列表）
public abstract void run();
//这是一个抽象方法
抽象类
如果一个类包含抽象方法，那么该类必须是抽象类。
定义格式：
abstract class 类名字{
}
public abstract class Animal{
public abstract void run();
}
抽象的使用
继承抽象类的子类**必须重写父类所有的抽象方法。**否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。
public class Cat extends Animal{
public void run(){
System.out.println("小猫在墙头走~~")
}
}
//创建子类对象并调用run方法
cat cat = new Cat();
cat.run();
此时的方法重写，是子类对父类抽象方法的完成实现，这种方法重写的操作，也叫做实现方法
注意事项
-
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法怎么样具体的方法体，没有意义
-
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super（），需要访问父类构造方法
-
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊类的结构设计
-
抽象类的子类，必须重写抽象父类的所有的抽象方法，除非该子类也是抽象类。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义
发红包的案例
群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：
- 群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
- 成员领取红包后，保存到成员余额中。
- 请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。
分析：
实现：
用户类
public class User {
private String name;//姓名
private int money;//余额
public User(){}//无参构造方法
//全参构造方法
public User(String name, int money) {
this.name = name;
this.money = money;
}
public void show(){
System.out.println("当前余额："+money);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
群主类
public class Manager extends User {
public Manager(){
//默认有super()
}
public Manager(String name, int money) {
super(name, money);
}
public ArrayList<Integer> send(int totalMoney,int count){
//首先需要一个集合，用来存储若干红包的余额
ArrayList<Integer> redList = new ArrayList<>();
//首先查看自己的余额
int leftMoney = super.getMoney();
if(totalMoney > leftMoney){
System.out.println("余额不足");
return redList;
}
//扣钱
super.setMoney(leftMoney-totalMoney);
//发红包：平均拆分为count份
int avg = totalMoney / count;
//余数，也就是零头
int mod = totalMoney % count;
//塞红包
for(int i = 0;i<count-1;i++){
redList.add(avg);
}
//最后的红包加上零头
redList.add(avg + mod);
//返回红包
return redList;
}
}
群员类
public class Member extends User{
public Member(){
}
public Member(String name, int money) {
super(name, money);
}
//返回0为失败，其他值为红包金额
public int receive(ArrayList<Integer> list){
//随机抓起一个集合中的索引编号
//如果list.size()<0则红包被抢完了
if(list.size()==0) return 0;
int index = new Random().nextInt(list.size());
//根据索引，从集合当中删除，返回值就是被删除的红包
int delta = list.remove(index);
//加余额
super.setMoney(super.getMoney()+delta);
return delta;
}
}
测试类/发红包类
public class Test {
public static void main(String[] args) {
Manager manager = new Manager("群主",100);
Member m1 = new Member("成员A",0);
Member m2 = new Member("成员B",0);
Member m3 = new Member("成员C",0);
Member m4 = new Member("成员D",0);
Member m5 = new Member("成员E",0);
//打包四个成员
ArrayList<Member> members = new ArrayList<>(Arrays.asList(m1,m2,m3,m4,m5));
//群主发20块钱，分3份
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要发的红包和金额：");
int totalMoney = sc.nextInt();
int count = sc.nextInt();
ArrayList<Integer> redList = manager.send(totalMoney,count);
//成员抢红包
run(manager,members,redList,totalMoney,count);
}
public static void run(Manager manager, ArrayList<Member> members,ArrayList<Integer> redList,int totalMoney,int count){
String yunqi = "";
for (int i = 0;i<members.size();i++){
Member m = members.get(i);
int flag = m.receive(redList);
if(flag == 0) {
System.out.println(m.getName()+"没抢到");
break;
}
System.out.print(m.getName()+"抢到了,");
m.show();
if(flag > totalMoney/count) {
yunqi = m.getName()+"是运气王";
}
}
System.out.println(yunqi);
System.out.println("我的余额："+manager.getMoney());
System.out.println("------------------------");
}
}
case3 接口
概述
接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么
接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法
（JDK 9）
| Java版本 | 接口新特性 |
|---|---|
| JDK 7及以前 | 常量、抽象方法 |
| JDK 8 | 默认方法、静态方法 |
| JDK 9 | 私有方法 |
接口的定义，它与定义类方式相似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并
不是类，而是另外一种引用数据类型
复习：引用类型：数组、类、接口…
接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象
类。
定义格式
public interface 接口名称{
//成员变量 / 常量
public static final int NUMBER_VALUE_1 = 10;
public abstract void method(){
///抽象方法
}
public default void method1(){
//默认方法 JDK8+
}
public default void method2(){
//静态方法 JDK8+
}
private void method3(){
//私有方法 JDK9+
}
}
**成员变量：**使用[static] [final]修饰，常量必须进行赋值，而且一旦赋值不能改变，常量名称必须完全大写，用下划线分割
抽象方法：使用abstract修饰，可以省略，没有方法体，供子类实现使用
**默认方法：**使用default修饰，不可省略，供子类调用或者子类重写（一般用来升级接口用，因为不需要实现类实现也可以直接调用）
**静态方法：**使用static修饰，可以在接口里直接调用
**私有方法：**使用private修饰，供接口中的默认方法或静态方法调用
基本实现
类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用implements关键字。
非抽象子类实现接口
- 必须重写接口中的所有方法
- 继承了接口的默认方法，可以直接调用，也可以重写，还可以不调用
- 实现格式
class 类名 implements 接口名{
//重写接口中的抽象方法【必须】
//重写接口中的默认方法【可选】
}
抽象方法的使用
必须全部实现
- 定义接口
public interface LiveAble{
//定义抽象方法
public abstract void eat();
//修饰符可以省略
void sleep();
}
- 定义实现类
public class Animal implements LiveAble{
@Override
public void eat(){
System.out.println("吃东西")
}
@Override
public void sleep(){
System.out.println("晚上睡觉")
}
}
- 定义测试类
public static void main(String[] args){
//创建实现类对象
Animal a = new Animal();
//调用实现方法
a.eat();
a.sleep();
}
输出：
吃东西
晚上睡
默认方法的使用
可以继承，可以重写，二选一，但是只能通过实现类的对象来调用
-
继承默认方法
-
定义接口：
public interface LiveAble { //默认方法 ，通过实现类来调用，使用default修饰 public default void fly(){ System.out.println("天上飞"); } } -
定义实现类
public class Animal implements LiveAble { // 继承，什么都不用写，直接调用 } -
定义测试类
public static void main(String[] args) { // 创建子类对象 Animal a = new Animal(); // 调用默认方法 a.fly(); } 输出结果：天上飞
-
-
重写默认方法
-
定义接口
-
定义实现类
public class Animal implements LiveAble { @Override //重写默认方法 public void fly() { System.out.println("我不想飞"); } } -
定义测试类
输出结果：我不想飞
-
静态方法的使用
静态与.class文件有关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
-
定义接口
public interface LiveAble{ //静态方法 使用static修饰 通过接口名调用 public static void run(){ System.out.println("跑起来"); } } -
定义实现类
public class Animal implements LiveAble{ //无法重写静态方法 雨女无瓜 } -
定义测试类
public class InterfaceDemo{ public static void main(String[] args){ //Animal.run; 【错误写法】 LiveAble.run();//【一定要通过接口名调用】 } } 输出结果：跑起来
私有方法的使用
- 私有方法：只有默认方法可以调用
- 私有静态方法：默认方法和静态方法可以调用
如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。
public interface LiveAble{
default void func(){
func1();
func2();
}
private void func1(){
System.out.println("跑起来");
}
private void func2(){
System.out.println("跑起来");
}
}
接口的多实现
在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
实现格式
class 类名 [extends 父类名] implements 接口1，接口2，接口3...{
//重写接口中抽象方法【必须】
//重写接口中默认方法【不重名时可选】
}
抽象方法
接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：
-
定义多个接口
interface A { public abstract void showA(); public abstract void show(); } interface B { public abstract void showB(); public abstract void show(); } -
定义实现类
public class C implements A,B{ @Override public void showA() { System.out.println("showA"); } @Override public void showB() { System.out.println("showB"); } //有同名的方法show 只需要重写一次 @Override public void show() { System.out.println("show"); } }
默认方法
接口中，有多个默认方法时，实现类都可以继承使用。如果默认方法有重名的，必须重写一次
-
定义多个接口
interface A { public default void methodA(){} public default void method(){} } interface B { public default void methodB(){} public default void method(){} } -
定义实现类
public class C implements A,B{ @Override //其他默认方法可以不实现，但是【同名的默认方法必须实现】 public void method() { System.out.println("method"); } }
静态方法
接口中，存在同名的静态方法不会冲突，原因是只能通过各自的接口名访问静态方法
优先级问题
当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法
-
定义接口
interface A{ public default void methodA(){ System.out.println("AAAAAA"); } } -
定义父类
class D{ public void methodA(){ System.out.println("DDDDDD") } } -
定义子类
class C extends D implements A{ //未重写methodA方法 } -
定义测试类
public class Test{ public static void main(String[] args){ C c = new C(); c.methodA(); } } 输出结果：DDDDDD
接口的多继承
一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。
-
定义父接口
interface A{ public default void method(){ System.out.println("AAA"); } } interface B{ public default void method(){ System.out.println("BBB"); } } -
定义子接口
interface D extends A,B{ @Override public default void method(){ System.out.println("DDD") } }
子接口重写默认方法时，default关键字可以保留
子类重写默认方法时，default关键字不可以保留
其他成员特点
- 接口中，没有定义成员变量，但是可以定义常量，其值不可以改变，默认用public static final修饰
- 接口中，没有构造方法，不能在里面创建对象
- 接口中，没有静态代码块
case4 多态
定义
多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也
是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态
多态指同一行为，具有多个不同表现形式
实现前提
- 继承或者实现【二选一】
- 方法的重写【不重写，无意义】
- 父类引用指向子类对象【格式体现】
多态的体现
父类类型 变量名 = new 子类对象;
变量名.方法名;
Fu f = new Zi();
f.method();
父类类型：指子类对象继承的父类类型，或者实现的父接口类型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
-
定义父类
public abstract class Animal{ public abstract void eat(); } -
定义子类
class Cat extends Animal{ public void eat(){ System.out.println("吃鱼"); } } class Dog extends Animal{ public void eat(){ System.out.println("吃骨头") } } -
定义测试类
public class Test{ public static void main(String[] args){ //多态形式，创建对象 Animal a1 = new Cat(); //调用的是Cat的eat a1.eat(); //多态模式，创建对象 Animal a2 = new Dog(); //调用的是Dog的eat a2.eat(); } }
多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用更能体现出多态的扩展性与便利
-
定义父类
public abstract class Animal { public abstract void eat(); } -
定义子类
class Cat extends Animal { public void eat() { System.out.println("吃鱼"); } } class Dog extends Animal { public void eat() { System.out.println("吃骨头"); } } -
定义测试类
public class Test { public static void main(String[] args) { // 多态形式，创建对象 Cat c = new Cat(); Dog d = new Dog(); // 调用showCatEat showCatEat(c); // 调用showDogEat showDogEat(d); /* 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */ howAnimalEat(c); showAnimalEat(d); } public static void showCatEat (Cat c){ c.eat(); } public static void showDogEat (Dog d){ d.eat(); } public static void showAnimalEat (Animal a){ a.eat(); } }
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了****，直接使用showAnimalEat都可以完成。
所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
case5 引用类型转换
多态的转型分为向上转型与向下转型两种
向上转型
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
当父类引用指向一个子类对象时，便是向上转型。
父类型 变量名 = new 子类型();
Animal a = new Cat();
向下转型
向下转型： 父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型
子类型 变量名 = (子类型) 父类变量名;
Cat c = (Cat) a;
转型的意义
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。
简而言之，就是父类对象想调用子类对象特有的方法
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void watchHouse() {
System.out.println("看家");
}
}
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat的eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat的catchMouse
}
}
转型的异常
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
}
}
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了instanceof 关键字，给引用变量做类型的校验
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
所以转换前可以做一个判断
public class Test{
public static void main(String[] args){
//向上转型
Animal a = new Cat();
a.eat(); //调用的是Cat的eat
//向下转型
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); //调用Cat的方法
}else if(a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); //调用Dog的方法
}
}
}
case6 接口多态的综合案例
笔记本电脑（laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。
定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。
案例实现
-
定义USB接口
interface USB{ void open(); //开启功能 void close(); //关闭功能 } -
定义鼠标类
public class Mouse implements USB{ @Override public void open() { System.out.println("鼠标开启了"); } @Override public void close() { System.out.println("鼠标关闭了"); } public void click(){ System.out.println("鼠标单击了一下"); } } -
定义键盘类
public class KeyBoard implements USB { @Override public void open() { System.out.println("键盘开启了"); } @Override public void close() { System.out.println("键盘关闭了"); } public void type(){ System.out.println("键盘在打字"); } } -
定义笔记本类
public class Laptop { public void run(){ System.out.println("开机"); } public void useUSB(USB usb){ //判断是否有USB设备 if(usb != null){ usb.open(); if(usb instanceof Mouse){ Mouse m = (Mouse) usb; m.click(); }else if(usb instanceof KeyBoard){ KeyBoard kb = (KeyBoard) usb; kb.type(); } //使用完毕后关闭设备 usb.close(); } } public void shutDown(){ System.out.println("关机"); } } -
定义测试类
public class Test { public static void main(String[] args) { Laptop laptop = new Laptop(); //开机 laptop.run(); //使用鼠标 USB u = new Mouse(); laptop.useUSB(u); //使用键盘 KeyBoard kb = new KeyBoard(); laptop.useUSB(kb); //关机 laptop.shutDown(); } }
case7 final类
概述
子类可以在父类的基础上改写父类内容，比如，方法重写 ，但是不能随意继承api提供的类，改写其内容。为了避免这种随意改写的情况，Java提供了final关键字，用于修饰不可改变内容。
final： 不可改变。可以用于修饰类、方法和变量。
- 类：被修饰的类，不能被继承。
- 方法：被修饰的方法，不能被重写。
- 变量：被修饰的变量，不能被重新赋值
修饰类
final class 类名 {
}
API中像 public final class String 、 public final class Math 、 public final class Scanner等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。
修饰方法
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
重写被 final 修饰的方法，编译时就会报错
修饰变量
-
局部变量——基本类型
基本类型的局部变量，被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; // 【报错】,不可重新赋值 } } -
局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改
public class FinalDemo2 { public static void main(String[] args) { // 创建 User 对象 final User u = new User(); // 创建 另一个 User对象 u = new User(); // 报错，指向了新的对象，地址值改变。 // 调用setName方法 u.setName("张三"); // 可以修改 } } -
成员变量
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一
- 显示初始化
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修饰的常量名称，一般都有书写规范，所有字母都大写
case8 权限修饰符
概述
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限
- public：公共的。
- protected：受保护的
- default：默认的
- private：私有的
访问能力
| public | protected | default | prive | |
|---|---|---|---|---|
| 同一类中 | √ | √ | √ | √ |
| 同一包中(子类与无关类) | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 不同包中的无关类 | √ |
可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
- 成员变量使用
private，隐藏细节。 - 构造方法使用
public，方便创建对象。 - 成员方法使用
public，方便调用方法
不加权限修饰符，其访问能力与default修饰符相同
case9 内部类
概述
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类
成员内部类
成员内部类 ：定义在类中方法外的类
class 外部类{
class 内部类{
}
}
在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时，Engine 就可以使用内部类来描述，定义在成员位置。
class Car { //外部类
class 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文件，但是前面冠以外部类的类名和$符号 。
比如，Person$Heart.class
匿名内部类【重点】
匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 `子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作
- 定义子类
- 重写接口中的方法
- 创建子类对象
- 调用重写后的方法
我们的目的，最终是为了调用方法，那么可以简化一下么？匿名内部类就是做这样的快
捷方式。
前提
匿名内部类必须继承一个父类或者实现一个父接口
格式
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 */ showFlay(new FlyAble(){ public void fly(){ System.out.println("我飞了~~~"); } }); } public static void showFly(FlyAble f){ f.fly(); } }
case10 引用类型用法总结
实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的
class作为成员变量
在定义一个类Role时，代码如下
class Role{
int id;//角色id
int bloood;//生命值
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、Armour、Role对象
Weapon wp = new Weapon("屠龙刀",9999999);
Armour ar - new Armour("麒麟甲",100000);
Role r = new Role();
//设置武器属性
r.setWeapon(wp);
//设置盔甲属性
r.setArmour(ar);
//攻击
r.attack();
//穿戴盔甲
r.wear();
}
}
输出结果：
使用屠龙刀,造成999999点伤害
穿上麒麟甲 ,生命值增加10000
类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象
interface作为成员变量
接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。所以，如果想扩展更强大技能，我们在Role 中，可以增加接口作为成员变量，来设置不同的技能。
定义接口
//法术攻击
public interface FaShuSkill{
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();
}
}
输出结果:
发动法术攻击:纵横天下
攻击完毕
发动法术攻击:逆转乾坤
攻击完毕
我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象
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);
}
}
接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。
669
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
