⭐ 多态(polymorphism)
多态指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个方法,具体实现会完全不同。 比如:同样是调用人“吃饭”的方法,中国人用筷子吃饭,英国人用刀叉吃饭,印度人用手吃饭。
多态的要点:
🐟 多态是方法的多态,不是属性的多态(多态与属性无关)。
🐟 多态的存在要有 3 个必要条件:继承,方法重写,父类引用指向子类对象。
🐟 父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。
【eg】多态和类型转换
class Animal {
public void shout() {
System.out.println("叫了一声!");
}
}
class Dog extends Animal {
public void shout() {
System.out.println("旺旺旺!");
}
public void seeDoor() {
System.out.println("看门中....");
}
}
class Cat extends Animal {
public void shout() {
System.out.println("喵喵喵喵!");
}
}
public class TestPolym {
public static void main(String[ ] args) {
Animal a1 = new Cat(); // 向上可以自动转型
//传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
animalCry(a1);
Animal a2 = new Dog();
animalCry(a2);//a2 为编译类型,Dog 对象才是运行时类型。
/*编写程序时,如果想调用运行时类型的方法,只能进行强制类型转换。否则通不过编译器的检查。*/
Dog dog = (Dog)a2;//向下需要强制类型转换
dog.seeDoor();
}
// 有了多态,只需要让增加的这个类继承 Animal 类就可以了。
static void animalCry(Animal a) {
a.shout();
}
/* 如果没有多态,我们这里需要写很多重载的方法。
* 每增加一种动物,就需要重载一种动物的喊叫方法。非常麻烦。
static void animalCry(Dog d) {
d.shout();
}
static void animalCry(Cat c) {
c.shout();
}*/
}
执行结果如下所示:
如上示例,给大家展示了多态最为多见的一种用法,即父类引用做方法的形参,实参可以是任意的子类对象,可以通过不同的子类对象实现不同的行为方式。
由此,我们可以看出多态的主要优势是提高了代码的可扩展性。但是多态也有弊端,就是无法调用子类特有的功能,比如,我不能使用父类的引用变量调用 Dog 类特有的seeDoor()方法。
那如果我们就想使用子类特有的功能行不行呢?行!这就是我们下面所写的内容:
对象的转型。
⭐ 对象的转型(casting)
🐟 父类引用指向子类对象,我们称这个过程为向上转型,属于自动类型转换。
🐟 向上转型后的父类引用变量只能调用它编译类型的方法,不能调用它运行时类型的方法。这时,我们就需要进行类型的强制转换,我们称之为向下转型。
【eg】对象的转型
public class TestCasting {
public static void main(String[ ] args) {
Object obj = new String("北京"); // 向上可以自动转型
// obj.charAt(0) 无法调用。编译器认为 obj 是 Object 类型而不是 String 类型
/* 编写程序时,如果想调用运行时类型的方法,只能进行强制类型转换。不然通不过编译器的检查。 */
String str = (String) obj; // 向下转型
System.out.println(str.charAt(0)); // 位于 0 索引位置的字符
System.out.println(obj == str); // true.他们俩运行时是同一个对象
}
}
执行结果如下所示:
在向下转型过程中,必须将引用变量转成真实的子类类型(运行时类型)否则会出现类型转换异常 ClassCastException。如下所示。
【eg】类型转换异常
public class TestCasting2 {
public static void main(String[ ] args) {
Object obj = new String("北京");
//真实的子类类型是 String,但是此处向下转型为 StringBuffer
StringBuffer str = (StringBuffer) obj;
System.out.println(str.charAt(0));
}
}
执行结果:
为了避免出现这种异常,我们可以使用 instanceof 运算符进行判断。
【eg】向下转型中使用 instanceof
public class TestCasting3 {
public static void main(String[ ] args) {
Object obj = new String("北京尚学堂");
if(obj instanceof String){
String str = (String)obj;
System.out.println(str.charAt(0));
}else if(obj instanceof StringBuffer){
StringBuffer str = (StringBuffer) obj;
System.out.println(str.charAt(0));
}
}
}
⭐ 抽象类
抽象方法和抽象类
抽象方法
🐟 使用 abstract 修饰的方法,没有方法体,只有声明。
🐟 定义的是一种“规范”,就是告诉子类必须要给抽象方法提供具体的实现。
抽象类
🐟 包含抽象方法的类就是抽象类。
🐟 通过抽象类,我们就可以做到严格限制子类的设计,使子类之间更加通用。
【eg】抽象类和抽象方法的基本用法
//抽象类
abstract class Animal {
abstract public void shout(); //抽象方法
}
class Dog extends Animal {
//子类必须实现父类的抽象方法,否则编译错误
public void shout() {
System.out.println("汪汪汪!");
}
public void seeDoor(){
System.out.println("看门中....");
}
}
//测试抽象类
public class TestAbstractClass {
public static void main(String[ ] args) {
Dog a = new Dog();
a.shout();
a.seeDoor();
}
}
抽象类的使用要点:
🐟 有抽象方法的类只能定义成抽象类
🐟 抽象类不能实例化,即不能用 new 来实例化抽象类。
🐟 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例,只能用来被子类调用。
🐟 抽象类只能用来被继承。
🐟 抽象方法必须被子类实现。
⭐ 接口 interface
接口就是一组规范(就像我们人间的法律一样),所有实现类都要遵守。
面向对象的精髓,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如 C++、Java、C#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。
接口的作用
为什么需要接口?接口和抽象类的区别?
接口就是比“抽象类”还“抽象”的“抽象类”,可以更加规范的对子类进行约束。全面地专业地实现了:规范和具体实现的分离。
接口是两个模块之间通信的标准,通信的规范。如果能把你要设计的模块之间的接口定义好,就相当于完成了系统的设计大纲,剩下的就是添砖加瓦的具体实现了。大家在工作中,做系统时往往就是使用“面向接口”的思想来设计系统。
接口和实现类不是父子关系,是实现规则的关系。比如:我定义一个接口 Runnable,Car 实现它就能在地上跑,Train 实现它也能在地上跑,飞机实现它也能在地上跑。就是说,如果它是交通工具,就一定能跑,但是一定要实现 Runnable 接口。
如何定义和使用接口
声明格式:
[访问修饰符] interface 接口名 [extends 父接口 1,父接口 2…] {
常量定义;
方法定义;
}
定义接口的详细说明:
🐟 访问修饰符:只能是 public 或默认。
🐟 接口名:和类名采用相同命名机制。
🐟 extends:接口可以多继承。
🐟 常量:接口中的属性只能是常量,总是:public static final 修饰。不写也是。
🐟 方法:接口中的方法只能是:public abstract。 省略的话,也是 public abstract。
注意:
🐟 子类通过 implements 来实现接口中的规范。
🐟 接口不能创建实例,但是可用于声明引用变量类型。
🐟 一个类实现了接口,必须实现接口中所有的方法,并且这些方法只能是 public 的。
🐟 JDK1.8(不含 8)之前,接口中只能包含静态常量、抽象方法,不能有普通属性、构造方法、普通方法。
🐟 JDK1.8(含 8)后,接口中包含普通的静态方法、默认方法。
【eg】接口的使用
public class TestInterface {
public static void main(String[ ] args) {
Volant volant = new Angel();
volant.fly();
System.out.println(Volant.FLY_HIGHT);
Honest honest = new GoodMan();
honest.helpOther();
}
}
/*飞行接口*/
interface Volant {
int FLY_HIGHT = 100; // 总是:public static final 类型的;
void fly(); //总是:public abstract void fly();
}
/*善良接口*/
interface Honest {
void helpOther();
}
/*Angel 类实现飞行接口和善良接口*/
class Angel implements Volant, Honest{
public void fly() {
System.out.println("我是天使,飞起来啦!");
}
public void helpOther() {
System.out.println("扶老奶奶过马路!");
}
}
class GoodMan implements Honest {
public void helpOther() {
System.out.println("扶老奶奶过马路!");
}
}
class BirdMan implements Volant {
public void fly() {
System.out.println("我是鸟人,正在飞!");
}
}
执行结果:
接口中定义静态方法和默认方法(JDK8)
JAVA8 之前,接口里的方法要求全部是抽象方法。
JAVA8(含 8)之后,以后允许在接口里定义默认方法和静态方法。
JDK8 新特性_默认方法
Java 8 及以上新版本,允许给接口添加一个非抽象的方法实现,只需要使用 default
关键字即可,这个特征又叫做默认方法(也称为扩展方法)。
默认方法和抽象方法的区别是抽象方法必须要被实现,默认方法不是。作为替代方式,接口可以提供默认方法的实现,所有这个接口的实现类都可以得到默认方法。
【eg】默认方法
public class Test {
public static void main(String[] args) {
A a = new Test_A();
a.moren();
}
}
interface A {
default void moren(){
System.out.println("我是接口 A 中的默认方法!");
}
}
class Test_A implements A {
@Override
public void moren() {
System.out.println("Test_A.moren");
}
}
JDK8 新特性_静态方法
JAVA8 以后,我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口(接口也是类,一种特殊的类),可以通过接口名调用。
如果子类中定义了相同名字的静态方法,那就是完全不同的方法了,直接从属于子类。可以通过子类名直接调用。
public class Test {
public static void main(String[] args) {
A.staticMethod();
Test_A.staticMethod();
}
}
interface A {
public static void staticMethod(){
System.out.println("A.staticMethod");
}
}
class Test_A implements A {
public static void staticMethod(){
System.out.println("Test_A.staticMethod");
}
}
静态方法和默认方法
本接口的默认方法中可以调用静态方法。
public class Test {
public static void main(String[] args) {
A a = new Test_A();
a.moren();
}
}
interface A {
public static void staticMethod(){
System.out.println("A.staticMethod");
}
public default void moren(){
staticMethod();
System.out.println("A.moren");
}
}
class Test_A implements A {
public static void staticMethod(){
System.out.println("Test_A.staticMethod");
}
}
接口的多继承
接口支持多继承。和类的继承类似,子接口 extends 父接口,会获得父接口中的一切。
【eg】接口的多继承
interface A {
void testa();
}
interface B {
void testb();
}
/**接口可以多继承:接口 C 继承接口 A 和 B*/
interface C extends A, B {
void testc();
}
public class Test implements C {
public void testc() {
}
public void testa() {
}
public void testb() {
}
}