8.1 接口

在设计LOL的时候，进攻类英雄有两种，一种是进行物理系攻击，一种是进行魔法系攻击

这时候，就可以使用接口来实现这个效果。

接口就像是一种约定，我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击。

物理攻击接口

创建一个接口 AD ，声明一个方法 physicAttack 物理攻击，但是没有方法体，是一个“空”方法

package charactor;public interface AD {//物理伤害public void physicAttack();
}

设计一类英雄，能够使用物理攻击

设计一类英雄，能够使用物理攻击，这类英雄在LOL中被叫做AD类：ADHero 继承了Hero 类，所以继承了name,hp,armor等属性

实现某个接口，就相当于承诺了某种约定

所以，实现了AD这个接口，就必须提供AD接口中声明的方法physicAttack() 实现在语法上使用关键字 implements

package charactor;public class ADHero extends Hero implements AD{@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}}

魔法攻击接口

package charactor;public class APHero extends Hero implements AP{@Overridepublic void magicAttack() {System.out.println("进行魔法攻击");}}

设计一类英雄，既能进行物理攻击，又能进行魔法攻击

一种英雄，能够同时进行物理攻击和魔法攻击比如伊泽瑞尔，皮城女警凯特琳

package charactor;//同时能进行物理和魔法伤害的英雄
public class ADAPHero extends Hero implements AD,AP{@Overridepublic void magicAttack() {System.out.println("进行魔法攻击");}@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}}

什么样的情况下该使用接口?

如上的例子，似乎要接口，不要接口，都一样的，那么接口的意义是什么呢

学习一个知识点，是由浅入深得进行的。这里呢，只是引入了接口的概念，要真正理解接口的好处，需要更多的实践，以及在较为复杂的系统中进行大量运用之后，才能够真正理解，比如在学习了多态之后就能进一步加深理解。

刚刚接触一个概念，就希望达到炉火纯青的学习效果，这样的学习目标是不科学的。

8.2 对象转型

明确引用类型与对象类型的概念

首先，明确引用类型与对象类型的概念在这个例子里，有一个对象 new ADHero(), 同时也有一个引用ad 对象是有类型的，是ADHero 引用也是有类型的，是ADHero 通常情况下，引用类型和对象类型是一样的接下来要讨论的类型转换的问题，指的是引用类型和对象类型不一致的情况下的转换问题

package charactor;public class Hero {public String name; protected float hp;public static void main(String[] args) {ADHero ad = new ADHero();}
}

子类转父类(向上转型)

所谓的转型，是指当引用类型和对象类型不一致的时候，才需要进行类型转换

父类指向子类对象是一定可以成功的。

package charactor;![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0cd3df775bab463f83dacdbb53e8c5ec~tplv-k3u1fbpfcp-watermark.image?)
public class Hero {public String name; protected float hp;public static void main(String[] args) {Hero h = new Hero();ADHero ad = new ADHero();//类型转换指的是把一个引用所指向的对象的类型，转换为另一个引用的类型//把ad引用所指向的对象的类型是ADHero//h引用的类型是Hero//把ADHero当做Hero使用，一定可以 h = ad;}
}

父类转子类(向下转型)

父类转子类，有的时候行，有的时候不行，所以必须进行强制转换。强制转换的意思就是转换有风险，风险自担。

package charactor;
import charactor1.Support;public class Hero {public String name; protected float hp;public static void main(String[] args) {Hero h =new Hero();ADHero ad = new ADHero();Support s =new Support();h = ad;ad = (ADHero) h; //可以成功h = s;ad = (ADHero)h;  //指向失败}
}

没有继承关系的两个类，互相转换

没有继承关系的两个类，互相转换，一定会失败。虽然ADHero和APHero都继承了Hero，但是彼此没有互相继承关系。

package charactor;
public class Hero {public String name;protected float hp;public static void main(String[] args) {ADHero ad = new ADHero();APHero ap = new APHero();// 没有继承关系的类型进行互相转换一定会失败，所以会出现编译错误ad = (ADHero) ap;}
}

实现类转换成接口(向上转型)

ad指向的对象是ADHero类型，这个类型实现了AD接口。 实现AD接口的类ADHero一定可以转换为接口；

换句话说，接口可以指向实现此接口的类。

package charactor;
public class Hero {public String name; protected float hp;public static void main(String[] args) {ADHero ad = new ADHero();AD adi = ad;}
}

接口转换成实现类(向下转型)

实现类指向接口不一定可以成功，需要强制转换。

10行： ad引用指向ADHero，而adi引用是接口类型：AD，实现类转换为接口，是向上转型，所以无需强制转换，并且一定能成功 12行: adi实际上是指向一个ADHero的，所以能够转换成功 14行： adi引用所指向的对象是一个ADHero，要转换为ADAPHero就会失败。

假设能够转换成功，那么就可以使用magicAttack方法，而adi引用所指向的对象ADHero是没有magicAttack方法的。

package charactor;
public class Hero {public String name; protected float hp;public static void main(String[] args) {ADHero ad = new ADHero();AD adi = ad;ADHero adHero = (ADHero) adi;ADAPHero adapHero = (ADAPHero) adi;adapHero.magicAttack();}
}

instanceof Hero 判断一个引用所指向的对象，是否是Hero类型，或者Hero的子类

8.3 重写

子类可以继承父类的对象方法；在继承后，重复提供该方法，就叫做方法的重写。

又叫覆盖 override

父类Item有一个方法，叫做effect

package property;public class Item {String name;int price;public void buy(){System.out.println("购买");}public void effect() {System.out.println("物品使用后，可以有效果");}}

子类LifePotion继承Item,同时也提供了方法effect

package property;public class LifePotion extends Item{public void effect(){System.out.println("血瓶使用后，可以回血");}}

调用重写的方法

调用就会执行重写的方法，而不是从父类的方法。所以LifePotion的effect会打印： "血瓶使用后，可以回血"

package property;
public class Item {String name;int price;public void effect(){System.out.println("物品使用后，可以有效果");}public static void main(String[] args) {Item i = new Item();i.effect();LifePotion lp =new LifePotion();lp.effect();}
}

如果没有重写这样的机制怎么样？

如果没有重写这样的机制，也就是说LifePotion这个类，一旦继承了Item，所有方法都不能修改了。

但是LifePotion又希望提供一点不同的功能，为了达到这个目的，只能放弃继承Item,重新编写所有的属性和方法，然后在编写effect的时候，做一点小改动.

这样就增加了开发时间和维护成本

package property;public class LifePotion {String name;int price;public void buy(){System.out.println("购买");}//只能放弃继承Itempublic void effect(){System.out.println("血瓶使用后，可以回血");}

8.4 多态

操作符的多态

同一个操作符在不同情境下，具备不同的作用如果+号两侧都是整型，那么**+代表数字相加** 如果+号两侧，任意一个是字符串，那么**+代表字符串**

package charactor;
public class Hero {public String name;protected float hp;public static void main(String[] args) {int i = 5;int j = 6;int k = i+j; //如果+号两侧都是整型，那么+代表 数字相加System.out.println(k);int a = 5;String b = "5";String c = a+b; //如果+号两侧，任意一个是字符串，那么+代表字符串连接System.out.println(c);    }
}

观察类的多态现象

观察类的多态现象：

i1和i2都是Item类型
都调用effect方法
输出不同的结果

多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态

Item.java:

package property;public class Item {String name;int price;public void buy(){System.out.println("购买");}public void effect() {System.out.println("物品使用后，可以有效果 ");}public static void main(String[] args) {//父类引用指向子类实例Item i1= new LifePotion();Item i2 = new MagicPotion();System.out.print("i1  是Item类型，执行effect打印:");i1.effect();System.out.print("i2也是Item类型，执行effect打印:");i2.effect();}}

LifePotion.java

package property;public class LifePotion extends Item {public void effect(){System.out.println("血瓶使用后，可以回血");}
}

MagicPotion.java

package property;public class MagicPotion extends Item{public void effect(){System.out.println("蓝瓶使用后，可以回魔法");}
}

类的多态条件

要实现类的多态，需要如下条件

父类（接口）引用指向子类对象
调用的方法有重写

那么多态有什么作用呢？通过比较不使用多态与使用多态来进一步了解

package charactor;import property.LifePotion;
import property.MagicPotion;public class Hero {public String name;protected float hp;//java学习交流:737251827  进入可领取学习资源及对十年开发经验大佬提问，免费解答！public void useLifePotion(LifePotion lp){lp.effect();}public void useMagicPotion(MagicPotion mp){mp.effect();}public static void main(String[] args) {Hero garen =  new Hero();garen.name = "盖伦";LifePotion lp =new LifePotion();MagicPotion mp =new MagicPotion();garen.useLifePotion(lp);garen.useMagicPotion(mp);}
}

如果不使用多态，假设英雄要使用血瓶和魔瓶，就需要为Hero设计两个方法. useLifePotion useMagicPotion

除了血瓶和魔瓶还有很多种物品，那么就需要设计很多很多个方法，比如 usePurityPotion 净化药水 useGuard 守卫 useInvisiblePotion 使用隐形药水等等等等

类的多态-使用多态

如果物品的种类特别多，那么就需要设计很多的方法比如useArmor,useWeapon等等

这个时候采用多态来解决这个问题设计一个方法叫做useItem，其参数类型是Item 如果是使用血瓶，调用该方法如果是使用魔瓶，还是调用该方法无论英雄要使用什么样的物品，只需要一个方法即可

package charactor;import property.Item;
import property.LifePotion;
import property.MagicPotion;public class Hero {public String name;protected float hp;public void useItem(Item i){i.effect();}public static void main(String[] args) {Hero garen =  new Hero();garen.name = "盖伦";LifePotion lp =new LifePotion();MagicPotion mp =new MagicPotion();garen.useItem(lp);garen.useItem(mp);     }
}

8.5 隐藏

与重写类似，方法的重写是子类覆盖父类的对象方法

隐藏，就是子类覆盖父类的类方法

父类

父类有一个类方法：battleWin

package charactor;public class Hero {public String name;protected float hp;//类方法，静态方法//通过类就可以直接调用public static void battleWin(){System.out.println("hero battle win");}}

子类隐藏父类的类方法

package charactor;public class ADHero extends Hero implements AD{@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}//隐藏父类的battleWin方法public static void battleWin(){System.out.println("ad hero battle win");}   public static void main(String[] args) {Hero.battleWin();ADHero.battleWin();}
}

8.6 super关键字

准备一个显式提供无参构造方法的父类

在实例化Hero对象的时候，其构造方法会打印“Hero的构造方法 "。

package charactor;
import property.Item;public class Hero {String name; //姓名   float hp; //血量float armor; //护甲int moveSpeed; //移动速度public void useItem(Item i){System.out.println("hero use item");i.effect();}public Hero(){System.out.println("Hero的构造方法 ");}public static void main(String[] args) {new Hero();}
}

实例化子类，父类的构造方法一定会被调用

实例化一个ADHero(), 其构造方法会被调用:其父类的构造方法也会被调用，并且是父类构造方法先调用。子类构造方法会默认调用父类的无参的构造方法。

package charactor;
public class ADHero extends Hero implements AD{@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}public ADHero(){System.out.println("AD Hero的构造方法");}public static void main(String[] args) {new ADHero();  }
}

父类显式提供两个构造方法

分别是无参的构造方法和带一个参数的构造方法

package charactor;
import property.Item;public class Hero {String name; //姓名float hp; //血量float armor; //护甲int moveSpeed; //移动速度public void useItem(Item i){System.out.println("hero use item");i.effect();}   public Hero(){System.out.println("Hero的无参的构造方法 ");}public Hero(String name){System.out.println("Hero的有一个参数的构造方法 ");this.name = name;}public static void main(String[] args) {new Hero();}
}

子类显式调用父类带参构造方法

package charactor;public class ADHero extends Hero implements AD{@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}public ADHero(String name){super(name);System.out.println("AD Hero的构造方法");}public static void main(String[] args) {new ADHero("德莱文");}
}

调用父类属性

package charactor;public class ADHero extends Hero implements AD{int moveSpeed=400; //移动速度@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}public int getMoveSpeed(){return this.moveSpeed;}public int getMoveSpeed2(){return super.moveSpeed;}public static void main(String[] args) {ADHero h= new ADHero();System.out.println(h.getMoveSpeed());System.out.println(h.getMoveSpeed2());  }
}

调用父类方法

ADHero重写了useItem方法，并且在useItem中通过super调用父类的useItem方法

package charactor;import property.Item;
import property.LifePotion;public class ADHero extends Hero implements AD {int moveSpeed = 400; // 移动速度@Overridepublic void physicAttack() {System.out.println("进行物理攻击");}public int getMoveSpeed() {return this.moveSpeed;}public int getMoveSpeed2() {return super.moveSpeed;}// 重写useItem，并在其中调用父类的userItem方法public void useItem(Item i) {System.out.println("adhero use item");super.useItem(i);}public static void main(String[] args) {ADHero h = new ADHero();LifePotion lp = new LifePotion();}
}

8.7 Object类

Object类是所有类的父类

声明一个类的时候，默认是继承了Object
toString()

Object类提供一个toString方法，所以所有的类都有toString方法。toString()的意思是返回当前对象的字符串表达。通过 System.out.println 打印对象就是打印该对象的toString()返回值

package charactor;public class Hero {public String name;protected float hp;public String toString(){return name;}public static void main(String[] args) {Hero h = new Hero();h.name = "盖伦";System.out.println(h.toString());//直接打印对象就是打印该对象的toString()返回值System.out.println(h);}
}

finalize()

当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件

当它被垃圾回收的时候，它的finalize() 方法就会被调用。

finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

equals()

equals() 用于判断两个对象的内容是否相同

假设，当两个英雄的hp相同的时候，我们就认为这两个英雄相同

System.out.println(h1.equals(h2));
System.out.println(h1.equals(h3));

这不是Object的方法，但是用于判断两个对象是否相同 更准确的讲，用于判断两个引用，是否指向了同一个对象

System.out.println(h1==h2);
System.out.println(h1==h3);

8.8 final

final修饰类

当Hero被修饰成final的时候，表示Hero不能够被继承；其子类会出现编译错误。

package charactor;public final class Hero extends Object {  String name; //姓名float hp; //血量
}

final修饰方法

Hero的useItem方法被修饰成final,那么该方法在ADHero中，不能够被重写

package charactor;import property.Item;public class Hero extends Object {public final void useItem(Item i){System.out.println("hero use item");i.effect();}   public static void main(String[] args) {new Hero();}
}

final修饰基本类型变量

final修饰基本类型变量，表示该变量只有一次赋值机会；

16行进行了赋值，17行就不可以再进行赋值了。

package charactor;public class Hero extends Object {float hp; //血量public static void main(String[] args) {final int hp;hp = 5;hp = 6;}
}

final修饰引用

final修饰引用：h引用被修饰成final，表示该引用只有1次指向对象的机会。所以17行会出现编译错误但是，依然通过h引用修改对象的属性值hp，因为hp并没有final修饰

package charactor;public class Hero extends Object {String name; //姓名float hp; //血量float armor; //护甲int moveSpeed; //移动速度public static void main(String[] args) {final Hero h;h  = new Hero();h  = new Hero();h.hp = 5;  }
}

常量

常量指的是可以公开，直接访问，不会变化的值比如 itemTotalNumber 物品栏的数量是6个

public static final int itemTotalNumber = 6;//物品栏的数量

8.9 抽象类

在类中声明一个方法，这个方法没有实现体，是一个“空”方法

这样的方法就叫抽象方法，使用修饰符“abstract"

当一个类有抽象方法的时候，该类必须被声明为抽象类

抽象类

为Hero增加一个抽象方法 attack，并且把Hero声明为abstract的。 APHero,ADHero,ADAPHero是Hero的子类，继承了Hero的属性和方法。但是各自的攻击手段是不一样的，所以继承Hero类后，这些子类就必须提供不一样的attack方法实现。

Hero.java

package charactor;public abstract class Hero {String name;float hp;float armor;int moveSpeed;public static void main(String[] args) {}// 抽象方法attack// Hero的子类会被要求实现attack方法public abstract void attack();
}

ADHero.java

package charactor;
public class ADHero extends Hero implements AD {public void physicAttack() {System.out.println("进行物理攻击");}@Overridepublic void attack() {physicAttack();}
}

抽象类可以没有抽象方法

Hero类可以在不提供抽象方法的前提下，声明为抽象类 一旦一个类被声明为抽象类，就不能够被直接实例化

package charactor;public abstract class Hero {String name;float hp;float armor;int moveSpeed;public static void main(String[] args) {//虽然没有抽象方法，但是一旦被声明为了抽象类，就不能够直接被实例化Hero h= new Hero();}
}

抽象类和接口的区别

package charactor;public interface AP {public static final int resistPhysic = 100;//resistMagic即便没有显式的声明为 public static final//但依然默认为public static finalint resistMagic = 0;//java学习交流:737251827  进入可领取学习资源及对十年开发经验大佬提问，免费解答！public void magicAttack();
}

8.10 内部类

非静态内部类

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

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

静态内部类

在一个类里面声明一个静态内部类：比如敌方水晶，当敌方水晶没有血的时候，己方所有英雄都取得胜利，而不只是某一个具体的英雄取得胜利。

与非静态内部类不同，静态内部类水晶类的实例化 不需要一个外部类的实例为基础，可以直接实例化。语法：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();}
}

匿名类

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

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

本地类

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

package charactor;public abstract class Hero {public abstract void attack();public static void main(String[] args) {//在匿名类中使用外部的局部变量damage 必须修饰为finalint 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);}

8.11 默认方法

什么是默认方法

默认方法是JDK8新特性，指的是接口也可以提供具体方法了，而不像以前，只能提供抽象方法

Mortal 这个接口，增加了一个默认方法 revive，这个方法有实现体，并且被声明为了default

package charactor;public interface Mortal {public void die();default public void revive() {System.out.println("本英雄复活了");}
}

假设没有默认方法这种机制，那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。

但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法

通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类

为什么会有默认方法

假设没有默认方法这种机制，那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。

但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法

通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类

JAVA基础学习-接口与继承相关推荐

261、Java基础38 - 接口与继承【对象转型】 2019.11.18
0.目录 1.明确引用类型与对象类型的概念 2.子类转父类(向上转型) 3.父类转子类(向下转型) 4.没有继承关系的两个类,互相转换 5.实现类转换成接口(向上转型) 6.接口转换成实现类(向下转型 ...
Java基础学习第九节——继承、重写
面向对象--继承 1. 继承 1.1 继承概念的引入继承是面向对象最显著的一个特性.继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力. 代码实现: 三个类都有重 ...
JAVA基础之接口与继承
在设计LOL的时候,进攻类英雄有两种,一种是进行物理系攻击,一种是进行魔法系攻击这时候,就可以使用接口来实现这个效果. 接口就像是一种约定,我们约定某些英雄是物理系英雄,那么他们就一定能够进行物理攻 ...
初学Java基础学习——抽象类和接口的区别
初学Java基础学习--抽象类和接口的区别一.关键字 1)抽象类的关键字 abstract class A{//定义一个抽象类: } class Test extends A{//子类使用exten ...
java基础学习整理(一)
java基础学习整理(一) lesson1: D0s命令: 1.回到根目录,>cd \ 2.复制命令行下的内容,右击标记所要复制的内容,这样就已经复制好了,右击粘贴就可以了. 3.查看,设置环境 ...
Java基础-面向接口（interface）编程
Java基础-面向接口(interface)编程作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.接口的概念接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的&q ...
Java基础学习：尚硅谷项目三开发团队调度软件
Java基础学习:尚硅谷项目三开发团队调度软件一.软件功能与结构设计 1. 软件功能该软件实现以下功能: 软件启动时,根据给定的数据创建公司部分成员列表(数组) 根据菜单提示,基于现有的公司成员 ...
尚学堂JAVA基础学习笔记_2/2
尚学堂JAVA基础学习笔记_2/2 文章目录尚学堂JAVA基础学习笔记_2/2 写在前面第10章 IO技术 1. IO入门 2. IO的API 3. 装饰流 4. IO实战 5. CommonsI ...
Java基础学习（9）
Java基础学习一.常用方法(API) 1.1 Math 1.2 System 1.3 Runtime 1. 4 .object 1.5 Objects 1.6 BigInteger BigInte ...

JAVA基础学习-接口与继承

8.7 Object类

8.8 final

8.9 抽象类

JAVA基础学习-接口与继承相关推荐

最新文章

热门文章