Java两周半速成之路（第七天）

一.多态

3.多态的好处:

提高了程序的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

演示：

package com.shujia.day08;public class Animal {String name;int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}public void eat() {System.out.println("吃饭");}public void sleep() {System.out.println("睡觉");}
}class Cat extends Animal {public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void sleep() {System.out.println("猫躺着睡");}public void youYong() {System.out.println("猫会游泳");}}class Tiger extends Animal {public Tiger() {}public Tiger(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("老虎吃肉");}@Overridepublic void sleep() {System.out.println("老虎趴着睡");}
}//创建工具类
class AnimalTool {/*构造工具类的两个条件：构造方法私有化成员方法必须是静态的*/public static void useAnimal( Animal animal){animal.sleep();animal.eat();}
}class Test1 {public static void main(String[] args) {Cat a1 = new Cat("xiaohua", 1);AnimalTool.useAnimal(a1);Tiger t1 = new Tiger("xiaohuang",3);AnimalTool.useAnimal(t1);}
}

4.多态的弊端:

不能访问子类特有成员方法

解决方法： 多态中的转型

4.1 多态中的转型

向下转型：父类引用转为子类对象

演示：

/*多态访问成员方法的弊端：无法访问子类中特有的成员方法向下转型：父类引用转为子类对象*/class Father{public Father() {}public void fun1(){System.out.println("100");}public void fun2(){System.out.println("200");}}
class Son extends Father{public Son() {}public void fun3(){System.out.println(300);}
}public class DuoTaidem2 {public static void main(String[] args) {Father f1 =new Son();         //   向上转型f1.fun1();f1.fun2();Son f2=(Son) f1;    //向下转型f2.fun3();      //300}
}

二、抽象类

1.概述：

现实生活中，我们并不能找到一个具体的事物叫做动物，在现实生活中，动物本身其实是一个概念/集合，是一个抽象的东西我们看不见摸不着。所以我们的程序中也不应该能够new出来，这就发生了程序和现实的冲突。 java为了更好的模拟现实生活，为了能够表示抽象的集合概念这样的思想，提供了一个关键字给我们使用：abstract

abstract：抽象的，可以修饰类，成员方法。

修饰类：类为抽象类,类无法new,无法被实例化（创建对象）

修饰方法：方法为抽象方法

2.注意事项：

1、抽象类无法被实例化，却可以在抽象类中编写构造方法，这里的构造方法意义是什么呢？

答案：为了子类能够成功创建对象，要想初始化子类，必选初始化其直接父类。

2、被abstract关键字修饰的方法，不允许有方法体的实现，连大括号都不能有。

3、抽象方法的类必须是抽象class类，不能是具体的class类（如果一个类有抽象方法，这个类必须是抽象类）

4、抽象class类中既可以存在抽象方法，也可以存在具体的实现方法

5、当一个具体的class类继承一个抽象类的时候，必须要实现抽象类中的所有抽象方法！！

6、抽象类与抽象类之间允许存在继承关系, 抽象类继承抽象类的时候，可以选择性地重写方法，也可以都不重写

演示：


/*
2.注意事项：
1、抽象类无法被实例化，却可以在抽象类中编写构造方法，这里的构造方法意义是什么呢？
答案：为了子类能够成功创建对象，要想初始化子类，必选初始化其直接父类。
2、被abstract关键字修饰的方法，不允许有方法体的实现，连大括号都不能有。
3、抽象方法的类必须是抽象class类，不能是具体的class类（如果一个类有抽象方法，这个类必须是抽象类）
4、抽象class类中既可以存在抽象方法，也可以存在具体的实现方法
5、当一个具体的class类继承一个抽象类的时候，必须要实现抽象类中的所有抽象方法 ！！
6、抽象类与抽象类之间允许存在继承关系, 抽象类继承抽象类的时候，可以选择性地重写方法，也可以都不重写*/abstract class Person{String naem;int age;String grade;public Person() {}public Person(String naem, int age, String grade) {this.naem = naem;this.age = age;this.grade = grade;}abstract void study();abstract void eat();public void fun1() {System.out.println("这是具体实现的方法fun");}}class Student extends Person {public Student() {}public Student(String naem, int age, String grade) {super(naem, age, grade);}@Overridevoid study(){System.out.println("学习");}@Overridevoid eat() {System.out.println("吃饭");}
}public class AbstractDemo1 {public static void main(String[] args) {Student s1 = new Student("小明",29,"三班");s1.eat();}
}

7.abstract不能和哪些关键字共存？

答案： static无意义 final 冲突 private 冲突

演示：


/*1、一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义? 表示现实生活中的一种概念集合2、abstract不能和哪些关键字共存static 冲突final 冲突private 冲突*/abstract class Demo{
//    public abstract static void fun1(); // 非法的修饰符组合: abstract和static//    public abstract final void fun2(); // 非法的修饰符组合: abstract和final//    private abstract void fun3(); // 非法的修饰符组合: abstract和private
}public class AbstractDemo3 {public static void main(String[] args) {}
}

三、接口

1.概述：

java提供了一个关键字 interface表示一个接口，主要是为了扩展一个类的额外功能

2.使用接口的注意事项（一）

（1）接口可以被看作一个特殊的类，JVM也会把接口编译成一个class文件

（2）接口中只允许出现抽象方法,默认是抽象方法,默认会在方法的前面加上public abstract修饰符

（3）当一个具体的类实现一个接口的时候，必须要重写其中所有抽象方法

(4) 在接口中，方法必须被定义为public或abstract形式，其他权限修饰符不被Java编译器认可。或者说，即使不将该方法声明为public形式了，他也是public形式。

3.使用接口的注意事项（二）

（1）抽象类也可以实现接口，但不是必须重写方法，可以选择性地重写

（2）接口中只允许常量出现，不允许出现变量，默认会在定义变量前面加上public static final

（3）一个类可以同时实现多个接口，接口之间使用英文逗号分割

（4）java允许一个类继承一个类的同时实现接口,可以实现多个接口

举例： class A extends B implements Inter1,Inter2,...{ }

（5）接口与接口之间是继承关系，接口之间继承允许多继承

面试题：java语言中允许多继承吗？

类与类之间：不允许接口与接口之间：允许

演示：

/*使用接口的注意事项（二）：1、抽象类也可以实现接口，但是不是必须重写方法，可以选择性地重写2、接口中只允许常量出现，不允许出现变量，默认会在定义变量前面加上public static final3、一个类可以同时实现多个接口，接口之间使用英文逗号分割4、java允许一个类继承一个类的同时实现接口，可以实现多个接口class A extends B implements Inter1,[Inter2,...]{}5、接口与接口之间是继承关系，接口之间继承允许多继承（面试题：java语言中允许多继承吗？从类与类之间继承和接口与接口之间继承回答）*/
interface xuLian1 {int a=10;void daQiu1();void daQiu2();
}interface xuLian2 {void tiaoShui();void tiaoGao();
}abstract class Animal1 implements xuLian1 {abstract void eat();abstract void sleep();}class Cat1 extends Animal implements xuLian1, xuLian2 {           //java允许一个类继承一个类的同时实现接口，可以实现多个接口@Overridepublic void daQiu1() {System.out.println("打球1");}@Overridepublic void daQiu2() {System.out.println("打球2");}@Overridepublic void tiaoShui() {System.out.println("跳水");}@Overridepublic void tiaoGao() {System.out.println("跳高");}public void jump() {System.out.println("原地蹦");}
}public class JieKouDemo1 {public static void main(String[] args) {Cat1 c1 = new Cat1();c1.tiaoGao();System.out.println(c1.a);
//        a=20;                           // 接口中只允许常量出现，不允许出现变量，默认会在定义变量前面加上public static final,不可赋值
//        System.out.println(c1.a);}
}