【Java基础】面向对象(三)
一、多态
概念
多态是继封装、继承之后,面向对象的第三大特性。
生活中,比如跑的动作,小猫、小狗和大象,跑起来是不一样的。再比如飞的动作,昆虫、鸟类和飞
机,飞起来也是不一样的。可见,同一行为,通过不同的事物,可以体现出来的不同的形态。多态,描述的就是这样的状态。
多态 (多种形态) 是同一个行为具有多个不同表现形式或形态的能力,多态就是同一个接口使用不同的实例而执行不同操作。
- 父类类型 变量名 = new 子类对象;
- 变量名.方法名();
- 父类类型:指子类对象继承的父类类型,或者实现的父接口类型。
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去
调用子类的重写方法。
使用多态的好处是,可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。实际开发的过程中,父类类型作为方法形式参数,传递子类对象给方法,进行方法的调用,更能体现出多态的扩展性与便利。
示例:
public class Animal {
//成员变量
private String name;
private int age;
public void run() {
System.out.println("动物跑起来......");
}
}
public class Cat extends Animal {
//新增的属性
private String color;
@Override
public void run() {
System.out.println("猫跑起来.....");
}
//新增的方法
public void catchMouse() {
System.out.println("抓老鼠......");
}
}
public class Dog extends Animal {
//新增的属性
private String kind;
@Override
public void run() {
System.out.println("狗狗跑起来......");
}
//新增的方法
public void keepDoor() {
System.out.println("看门........");
}
}
package com.tuling.part1;
public class TestAnimal {
public static void show(Animal animal) {//会根据传入的参数的不同,调用不同的子类重写的方法,体现了多态的特征
animal.run();//分别调用子类的重写,体现了多态的特征
}
public static void main(String[] args) {
show(new Animal());
show(new Cat());//以Cat为对象调用show方法
show(new Dog());//以Dog为对象调用show方法
}
}
父子对象之间的转换分为了向上转型和向下转型 , 它们区别如下:
- 向上转型: 通过子类对象 (小范围) 实例化父类对象 (大范围),这种属于自动转换。
注意: 其意义在于当我们需要多个同父的对象调用某个方法时,通过向上转换后,则可以确定参
数的统一,方便程序设计。
对象的向上转型(安全的):会失去子类新增。
子类对象,被看做了父类的类型,那么就不能访问子类的新增, 只能访问父类的属性和方法,以及子类重写。
示例:
引用类型转换
public class TestAnimal {
public static void show(Animal animal) {
animal.run();
//没有办法访问子类新增的方法
// animal.catchMouse();
// animal.keepDoor();
}
public static void main(String[] args) {
//Java面向对象的多态
Animal cat = new Cat();//向上转型
System.out.println("------------");
Animal animal = new Animal();
System.out.println("------------");
Animal dog = new Dog();//向上转型
System.out.println("===========================");
show(cat);//访问子类重写
System.out.println("----------------");
show(animal);
System.out.println("----------------");
show(dog);//访问子类重写
}
}
- 向下转型: 通过父类对象 (大范围) 实例化子类对象 (小范围),这种属于强制转换。
为什么要转型
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误。也就是说,不
能调用子类拥有,而父类没有的方法。编译都错误,更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以,想要调用子类特有的方法,必须做向下转型。
instanceof关键字
在 Java 中,向下转型是为了通过父类强制转换为子类,从而来调用子类独有的方法,为了保证向下转型的顺利完成,在 Java 中提供了一个关键字 instanceof, 通过 instanceof 可以判断某对象是否是某类的实例,如果是则返回 true, 否则为 false。
instanceof:判断某个对象是否是某个类的实例:类以及继承的父类。
示例:
public class TestAnimal {
public static void show(Animal animal) {
animal.run();
//没有办法访问子类新增的方法
// animal.catchMouse();
// animal.keepDoor();
if (animal instanceof Cat) {
Cat catObj = (Cat) animal;//向下转型
catObj.catchMouse();
} else if (animal instanceof Dog) {
Dog dogObj = (Dog) dogobj;//向下转型
dogObj.keepDoor();
}
}
public static void main(String[] args) {
//Java面向对象的多态
Animal cat = new Cat();//向上转型
System.out.println("------------");
Animal animal = new Animal();
System.out.println("------------");
Animal dog = new Dog();//向上转型
System.out.println("===========================");
show(cat);
System.out.println("----------------");
show(animal);
System.out.println("----------------");
show(dog);
}
}
父类 对象1 = new 父类();
子类 对象2 = new 子类();
父类 对象3 = new 子类();
看一个对象能够访问哪些成员,看=左边是定义的是什么类型
- 父类类型:只能访问父类的属性和方法
- 子类类型:可以访问父类的属性和方法,子类新增,子类重写
看一个对象最终访问哪个方法,看=右边是什么类型的对象
- 父类对象:父类属性和方法
- 子类对象:父类的属性和方法,以及子类重写的方法
二、Object类
概述
所有的类,都是以继承结构存在的。如果没有显式的父类,默认继承Object类。
class Person{}
相当于
class Personextends Object{}
class Student extends Person {}//学生类继承Person类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层。
- 任何类,如没有书写extends显式继承某个类,都默认直接继承Object类,否则为间接继承。
- Object类中所定义的方法,是所有对象都具备的方法。
- Object类型可以存储任何对象。
- 作为参数,可接受任何对象。
- 作为返回值,可返回任何对象。
常用方法
getClass()
public final Class<?> getClass(){...}
//返回引用中存储的实际对象类型
//通常用于判断两个引用中实际存储对象类型是否一致
hashCode()
public int hashCode(){...}
//返回该对象的十进制的哈希码值
//哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值
toString()
public String toString(){...}
//返回该对象的字符串表示(表现形式)
//可以根据程序需求覆盖该方法,如:展示对象各个属性值
equals()
public boolean equals(Object obj){...}
//默认实现为(this == obj),比较两个对象地址是否相同
//可进行覆盖,比较两个对象的内容是否相同
equals重写步骤:
- 比较两个引用是否指向同一个对象。
- 判断obj是否为null。
- 判断两个引用指向的实际对象类型是否一致。
- 强制类型转换。
- 依次比较各个属性值是否相同。
示例:
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// @Override
// public String toString() {
// return "name:" + name + ";age" + age;
// }
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/**
* equals重写步骤:
* 比较两个引用是否指向同一个对象。
* 判断obj是否为null。
* 判断两个引用指向的实际对象类型是否一致。
* 强制类型转换。
* 依次比较各个属性值是否相同。
*/
// @Override
// public boolean equals(Object obj){
// if(this==obj){
// return true;
// }
// if(obj==null||this.getClass()!=obj.getClass()){
// return false;
// }
// //向下转型是为了调用子类新增的属性和方法
// Person person = (Person) obj;
//
// if(this.getName().equals(person.getName())&&this.getAge()==person.getAge()){
// return true;
// }
//
//
// return false;
// }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class TestPerson {
public static void main(String[] args) {
Person p1 = new Person("wowo", 23);
Class<? extends Person> aClass = p1.getClass();//返回引用中存储的实际对象类型。
System.out.println("aClass:" + aClass);
Person p2 = new Person();
Class<? extends Person> aClass1 = p2.getClass();
System.out.println("aClass1:" + aClass1);
Student stu = new Student();
System.out.println(stu.getClass());
System.out.println("-----------------------------------------------");
System.out.println("p1.hashCode:" + p1.hashCode());//返回该对象的十进制的哈希码值。
System.out.println("p2.hashCode():" + p2.hashCode());
System.out.println("-------------------------------");
System.out.println("p1:" + p1.toString());//有时候我们不只想看这个对象的全类名,我们想看这个对象的成员变量的值
System.out.println("------------------------------------");
Person person1 = new Person("zhangsan", 23);
Person person2 = new Person("zhangsan", 23);
System.out.println("person1 == person2:" + (person1 == person2));//==比较的是内存地址
System.out.println("person1.equals(person2):" + (person1.equals(person2)));//我们比较两个对象,其实我们是想比较一下对象的成员变量的值是否相等
}
}
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列。
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象。
- 垃圾回收: 由GC销毁垃圾对象,释放数据存储空间。
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。
- 手动回收机制:使用System.gc(); 通知JVM执行垃圾回收。
示例:
public class Student extends Person {
@Override
protected void finalize() throws Throwable {
System.out.println("Student finalize()方法。。。。。");
}
}
public class TestFinalize {
public static void main(String[] args) {
new Student();
new Student();
new Student();
System.out.println("-------------");
//手动GC
System.gc();
System.out.println("回收垃圾");
}
}
三、抽象类
程序是用来模拟现实世界、解决现实问题的;现实世界中存在的都是“动物”具体的子类对象,并不存在“动物”对象,所以,Animal不应该被独立创建成对象。
将子类的共同特征进行抽取,抽象成一个父类。如果有的功能在父类中定义了,但是没有具体的实
现,那么可以定义为抽象的,等待子类实现即可。
作用:
- 可被子类继承,提供共性属性和方法。
- 可声明为引用,更自然的使用多态。
抽象类 :包含抽象方法的类;
- 被abstract修饰的类,称为抽象类;
- 抽象类意为不够完整的类、不够具体的类;
抽象方法 : 没有方法体的方法。
抽象类与抽象方法的定义
- 抽象类定义的格式
public abstract class 类名 {
}
- 抽象方法定义的格式
public abstract 返回值类型 方法名(参数);
示例:
//抽象类
public abstract class Animal {//有抽象方法一定要定义成抽象类
//成员变量
private int age;
private String color;
//无参构造函数
public Animal() {
}
//有参构造函数
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
//抽象方法
public abstract void eat();
//抽象方法
public abstract void run();
//成员方法
public void print() {
System.out.println("name.....");
}
//类方法
public static void test() {
}
}
//子类,实现父类中定义的抽象方法
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼.....");
}
@Override
public void run() {
System.out.println("猫跑起来....");
}
}
注意事项
- 抽象类和抽象方法都需要被 abstract 修饰。抽象方法一定要定义在抽象类中。
- 抽象类不可以直接创建对象,原因:调用抽象方法没有意义。
- 只有覆盖了抽象类中所有的抽象方法后,其子类才可以创建对象,否则该子类还是一个抽象类。
- 之所以继承抽象类,更多的是在思想,是面对共性类型操作会更简单。
- 抽象类不允许被实例化,因为可能包含有抽象方法,必须等待子类来继承,并且实现抽象方法。子类积极的实现父类中的抽象方法,但是如果没有全部实现,那么子类也是抽象的,要再等子类来继承,并且实现抽象方法。
重要的结论:抽象类和类比较,除了不能实例化之外,没有任何区别。
- 抽象类一定是个父类 ?
- 是的,因为不断抽取而来的。
- 抽象类中是否可以不定义抽象方法?
- 是可以的,那这个抽象类的存在到底有什么意义呢?
- 不让该类创建对象,方法可以直接让子类去使用。
- abstract关键字,不能和static,private,final等关键字搭配使用。
abstract与static:
层面 | 内容 |
---|---|
what | abstract用来声明抽象方法,抽象方法没有方法体,不能被直接调用,必须在子类overriding后才能使用;static用来声明静态方法,静态方法可以被类及其对象调用 |
how | static与abstract不能同时使用 |
why | 用static声明方法表明这个方法在不生成类的实例时可直接被类调用,而abstract方法不能被调用,两者矛盾 |
四、接口
概述
接口,是Java语言中一种引用类型,是方法的集合。如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法(JDK 9)。
接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
引用数据类型:数组,类,接口。
接口就是一种约定、契约,一种规范。例如,生活中的USB接口,鼠标、键盘、U盘等只要遵循了USB接口规范,那么就可以正常使用。
接口定义
含有抽象方法
抽象方法:使用 abstract 关键字修饰,可以省略,没有方法体,供子类实现使用。
代码如下:
public interface InterFaceName {
public abstract void method();
}
含有默认方法和静态方法
默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。
静态方法:使用 static 修饰,供接口直接调用。
代码如下:
public interface InterFaceName {
public default void method() {
// 执行语句
}
public static void method2() {
// 执行语句
}
}
含有私有方法和私有静态方法
(注意:需要JDK9及以上才可以定义)
私有方法:使用 private 修饰,供接口中的默认方法或者静态方法调用。
代码如下:
public interface InterFaceName {
private void method() {
// 执行语句
}
}
接口实现
接口要有实现类来实现接口中的抽象方法。
子类和抽象父类的关系:extends
实现类和接口的关系:implements
类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。
非抽象子类实现接口:
- 必须重写接口中所有抽象方法。
- 继承接口的默认方法,即可以直接调用,也可以重写。
实现格式:
public class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}
注意:
- 接口中抽象方法必须全部实现;
- 接口中默认方法可以继承,可以重写,二选一,但是只能通过实现类的对象来调用;
- 接口中静态方法只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用。
示例:
//接口
public interface Usb {
//静态的常量
public static final double PI = 3.14;//定义的变量会默认加上public static final,故可省略不写
//抽象方法;
public abstract void start();//定义的抽象方法会默认加上public abstract,故可省略不写
public abstract void stop();
//默认方法
public default void fun1() {//定义的默认方法会默认加上public,故可省略不写
System.out.println("默认方法......");
}
//静态方法
public static void fun2() {//定义的静态方法会默认加上public,故可省略不写
System.out.println("静态方法......");
}
//JDK9及以上可定义私有方法
// private void fun3(){
// System.out.println("私有方法");
// }
}
public class Mouse implements Usb {
@Override
public void start() {
System.out.println("鼠标开始工作");
}
@Override
public void stop() {
System.out.println("鼠标结束工作");
}
//重写了
@Override
public void fun1() {
System.out.println("鼠标的默认方法....");
}
}
public class Keyboard implements Usb {
@Override
public void start() {
System.out.println("键盘开始工作...");
}
@Override
public void stop() {
System.out.println("键盘结束工作...");
}
}
一个类可以实现多个接口
- 接口最重要的体现:解决单继承的弊端,将多继承这种机制在Java中通过多实现完成了。
示例:
public interface Fu1 {
void fun1();
}
public interface Fu2 {
void fun2();
}
class Sun implements Fu1, Fu2 {
@Override
public void fun1() {
}
@Override
public void fun2() {
}
}
- 多继承的弊端是什么?
多继承时,当多个父类中有相同的功能时,子类调用会产生不确定性。其实核心原因就是在于多继承父类中功能有主体,而导致调用运行时,不确定运行哪个主体内容。
- 为什么多实现能解决这一弊端呢?
因为接口中的功能都没有方法体,由子类来明确。
一个类继承类同时可以实现接口
- 类与类之间可以通过继承产生关系,接口和类之间可以通过实现产生关系。当一个类已经继承了一个父类,它又需要扩展额外的功能,这时接口就派上用场了。
- 子类通过继承父类扩展功能,通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其他类中的功能,这时就需要通过实现接口来完成。
- 接口的出现解决了单继承的局限性。父类中定义的事物的基本功能,接口中定义的事物的扩展功能。
示例:
public class Fu {
}
//一个类可以实现多个接口
//一个类继承类同时可以实现接口
//接口的多继承
public class Zi extends Fu implements Fu1, Fu2 {
@Override
public void fun1() {
}
@Override
public void fun2() {
}
}
接口的多继承
- 多个接口之间可以使用 extends 进行继承
示例:
public interface Children extends Fu1, Fu2 {
void childFu1();
}
- 在开发中如果多个接口中存在相同方法,这时若有个类实现了这些接口,那么就要实现接口中的方法,由于接口中的方法是抽象方法,子类实现后也不会发生调用的不确定性。
和抽象类的区别
相同点:
- 都存在抽象方法;
- 不能创建对象,不能实例化;
- 可以作为引用类型;
- 具备Object类中所定义的方法。
不同点:
- 所有属性都是公开静态常量,隐式使用public static final修饰;
- 所有方法都是公开抽象方法,隐式使用public abstract修饰;
- 没有构造方法、动态代码块、静态代码块。
接口的好处
- 接口的出现降低了耦合性;
- 设计与实现完全分离,更容易更换具体实现;
- 更容易搭建程序框架。