Java基础：Day10笔记内容 （多态概述、抽象类）

1.多态概述
同一个事物,在不同的时刻表现出不同的状态。
代码中如何体现:
要有继承, 要有方法重写, 父类引用指向子类对象
示例
class DuoTaiDemo {
public static void main(String[] args) {
//父类引用指向子类对象
Animal a = new Cat();//这就是多态
a.eat();
}
}
class Animal {
public void eat() {
System.out.println(“动物吃”);
}
}
class Cat extends Animal {
public void eat() { //方法重写父类的eat()
System.out.println(“吃鱼”);
}
}
运行结果

多态的成员访问特点
成员变量：编译看左边, 运行看左边
成员方法：编译看左边，运行看右边对象(注意:这就是多态的精华)
构造方法：子类不能继承构造方法,默认访问父类空参构造
静态方法：编译看左边，运行看左边
示例
class DuoTaiDemo2 {
public static void main(String[] args) {
Animal a = new Cat();//父类引用指向子类对象, 这就是多态
//System.out.println(a.name);//编译看左边,左边Animal没有name
//成员方法
//a.catchMouse();//java:24: 错误: 找不到符号
//a.method();//Animal method 静态方法与类相关
Cat c2 = new Cat();//创建Cat的对象
c2.method(); //调用Cat的method()方法Cat method
}
}
class Animal {
String name = “Animal”;
public void eat() {
System.out.println(“动物吃”);
}
public void catchMouse() {
System.out.println(“Animal catchMouse”);
}
public static void method() {
System.out.println(“Animal method”);
}
}
class Cat extends Animal {
String name = “Cat”;
public void eat() {
System.out.println(“吃鱼”);
}
public void catchMouse() {
System.out.println(“抓老鼠”);
}
public static void method() {
System.out.println(“Cat method”);
}
}
运行结果

多态的好处: 提高代码的扩展性；
如何使用多态?
1.写一个父类
2. 写一个或多个子类, 重写父类的方法
3.写一个使用类,在使用类中写一个方法,方法的参数类型定义为父类类型.
4.调用使用类的方法,传入不同的子类对象
示例
class DuoTaiDemo3 {
public static void main(String[] args) {
Cat c = new Cat();//创建Cat的对象
Dog d = new Dog(); //创建Dog的对象
AnimalTool.use(c);//使用多态调用
System.out.println(“———–”);
AnimalTool.use(d);
}
}
//创建使用工具类
class AnimalTool {
//构建一个带Animal对象的方法
public static void use(Animal a) {//a = new Cat(),a = new Dog();
a.eat();
a.sleep();
a.show();
}
}
//创建父类Animal
class Animal {
public void eat() { }
public void sleep() { }
public void show() {}
}
class Dog extends Animal { //创建Dog类，继承Animal
public void eat() {
System.out.println(“吃肉骨头”);
}
public void sleep() {
System.out.println(“狗趴着睡”);
}
public void show() {
System.out.println(“狗秀肌肉”);
}
}
class Cat extends Animal {//创建Cat类，继承Animal
public void eat() {
System.out.println(“吃鱼”);
}
public void sleep() {
System.out.println(“猫蜷缩着睡”);
}
public void show() {
System.out.println(“猫show身材”);
}
}
运行结果

多态的弊端: 不能调用子类特有功能.
如何解决: 向下转型(强制转换):
示例
class DuoTaiDemo4 {
public static void main(String[] args) {
Animal a = new Cat();//多态方式创建Cat的对象
a.eat();//ok
//a.catchMouse();//No java:9: 错误: 找不到符号
System.out.println(“————————”);
//强制转换,向下转型
Cat c = (Cat)a; //把动物变成猫,因为它就是猫对象,所以可以强转
c.eat();
c.catchMouse();
}
}
class Animal {
public void eat() {
System.out.println(“Animal 吃”);
}
}
class Cat extends Animal {
public void eat() {
System.out.println(“吃鱼”);
}
public void catchMouse() {
System.out.println(“抓老鼠”);
}
}
运行结果

向上转型和向下转型
向上转型:
1. Animal a = new Cat();
2. Cat c = new Cat(); Animal a2 = c;
向下转型(强制转换): Cat c2 = (Cat)a;
注意：java.lang.ClassCastException,异常经常在向下转型中出现,不能指鹿为马.
2.抽象类概述及特点
1.抽象类和抽象方法必须用abstract关键字修饰
abstract class 类名 {}
public abstract void eat();
2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类中已实现的方法,是直接让子类使用的
抽象类中抽象方法,是让子类重写的.
3.抽象类不能实例化
实例化抽象类的子类: Animal a = new Cat();
4.抽象类的子类
要么是抽象类,要么重写抽象类中的所有抽象方法(推荐这个)
示例
class AbstractDemo {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
}
}
//有抽象方法的类,不能像普通类一样被使用,要加abstract修饰。
abstract class Animal {
//抽象的吃方法
public abstract void eat();//方法体没意义,可以不写,加上abstract修饰
//可以没有抽象方法
public void show() {
System.out.println(“Animal show”);
}
}
abstract class Dog extends Animal {}
class Cat extends Animal {
public void eat() {
System.out.println(“猫吃小鱼”);
}
}
运行结果

3.抽象类的成员特点
成员变量：变量,常量
成员方法：抽象方法,已实现的方法(实例方法)
构造方法：有,既然抽象类不能实例化,那么它的构造有何用? 给子类访问.
抽象类的成员总结:
1.普通类有的抽象类都有
2.可以有抽象方法.
示例
class AbstractDemo2 {//猫狗案例抽象类版
public static void main(String[] args) {
Cat c = new Cat(“加菲猫”,”yellow”);//直接使用子类
c.show();
c.eat();
c.sleep();
c.catchMouse();
System.out.println(“————–”);
Animal a = c;//多态
a.show();
a.eat();
a.sleep();
//a.catchMouse();//No
Cat c2 = (Cat)a;
c2.catchMouse();
System.out.println(“————–”);
a = new Dog(“来福”,”Black”);
a.show();
a.eat();
a.sleep();
//a.catchDisk();//No
Dog d = (Dog)a;
d.catchDisk();
}
}
abstract class Animal {
String name;
String color;
public Animal() {}
public Animal(String name,String color) {
this.name = name;
this.color = color;
}
public abstract void eat(); //动物吃
public abstract void sleep(); //动物睡
public void show() {
System.out.println(name + “…” + color);
}
}
class Cat extends Animal {
public Cat() {}
public Cat(String name,String color) {
super(name,color);
}
public void eat() { //吃
System.out.println(“吃条小鱼”);
}
public void sleep() { //睡
System.out.println(“猫蜷缩着睡”);
}
public void catchMouse() { //特别功能
System.out.println(“老鼠追击…..”);
}
}
class Dog extends Animal {
public Dog() {}
public Dog(String name,String color) {
super(name,color);
}
public void eat() { //吃
System.out.println(“吃根骨头”);
}
public void sleep() { //睡
System.out.println(“狗趴着睡”);
}
public void catchDisk() { //特别功能
System.out.println(“飞盘追击……..”);
}
}
运行结果

4.接口
概述: 接口体现的是事物的扩展功能.并不给出具体实现。
从设计理念上：
抽象类: Animal,凡是继承Animal的都是动物一族的,是一个体系的。
接口 : 体现的是事物的扩展功能,不是全部这个类型的对象都具备的。
实现这个接口的子类可能不是一个体系的。
从代码上：
接口： 抽象得彻底的抽象类。
特点:
1.接口用关键字interface表示, 格式：interface 接口名 {}
类实现接口用implements表示, 格式：class 类名 implements 接口名 {}
2.接口不能实例化
3.接口的实现类要么是抽象类,要么重写接口中的所有抽象方法.
接口的成员特点:
成员变量都是常量, 默认用public static final 修饰
成员方法只能有抽象方法,默认用public abstract 修饰
没有构造方法
示例
interface Jumpping {//定义一个接口Jumpping
public abstract void jump();//创建一个抽象方法jump(会跳高)
}
//创建一个JumpCat类，实现Jumpping接口(部分被培训的猫会跳高)
class JumpCat implements Jumpping {
public void jump() {
System.out.println(“跳高猫正在表演跳高….”);
}
}
//创建一个JumpStudent类实现Jumpping接口
class JumpStudent implements Jumpping {
public void jump() {
System.out.println(“跳高学生正在表演跳高….”);
}
}
class InterfaceDemo {
public static void main(String[] args) {
//多态方式创建JumpCat对象
Jumpping ju = new JumpCat();
ju.jump();
}
}
运行结果

接口与接口的关系
继承关系: 单继承,也可以多继承
interface 游泳 {};
interface 舞蹈 {};
interface 花样游泳 extends 游泳,舞蹈 {
public abstract void 团队合作();
}
5.类名作为参数时
1.类名作为方法的参数,调用方法需要传递该类的对象
2.抽象类名作为方法的参数,调用方法需要传递抽象类的子类对象
3.接口作为方法的参数,调用方法需要传递的是接口的实现类对象
示例
interface Jumpping {
public abstract void jump();
}
class JumpCat implements Jumpping {
public void jump() {
System.out.println(“JumpCat jump!”);
}
}
class ArgsDemo {
public static void main(String[] args) {
JumpCat jc = new JumpCat();//创建一个JumpCat对象
//调用test方法，传递JumpCat对象jc
test(jc);
}
public static void test(Jumpping jp) {//接口多态,接口引用指向实现类对象
jp.jump();//JumpCat jump
}
}
运行结果

1.类名作为返回值类型,实际返回的是该类型的对象
2.抽象类名作为返回值类型,实际返回的是抽象类的子类对象
示例
class Demo {
public int getInt() {
return 100;
}
public Student getStudent() {
return new Student();
}
}
class Student {
public void show() {
System.out.println(“学霸秀学习..”);
}
}
class ArgsDemo2 {
public static void main(String[] args) {
Demo d = new Demo(); //创建Demo对象
//调用getStudent()方法，得到类Student的对象，然后调用show()方法
d.getStudent().show();
}
}
运行结果

3.接口名作为返回值类型,实际返回的是接口的实现类对象
示例
class Demo {
public Jumpping getJumper() {//实际返回的是接口的实现类对象
//JumpStudent stu = new JumpStudent();
//return stu;
return new JumpStudent();
}
}
interface Jumpping { //跳高
public abstract void jump();
}
class JumpStudent implements Jumpping {
public void jump() {
System.out.println(“跳高健将在跳高….”);
}
}
class ArgsDemo3 {
public static void main(String[] args) {
Demo d = new Demo(); //创建一个Demo对象
//调用getJumper()方法，返回一个JumpStudent()类，赋给Jumpping对象
Jumpping jp = d.getJumper();
jp.jump();
}
}
运行结果

部分笔记内容，整个笔记一共27天，打包下载：
网盘地址——链接：http://pan.baidu.com/s/1c1iem6c 密码：8lj8