Day15-面向对象
Day15-面向对象
方法重写（覆盖）Override
当父类提供的方法无法满足子类的需求时，可以在子类中定义和父类相同的方法进行重写
要求：
方法名，参数列表，返回值类型必须与父类相同
访问权限符可以与父类相同或比父类更加宽泛
执行机制：子类重写父类方法之后，调用时优先执行子类重写后的方法
public class TestOverride {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.sleep();
}
}
//父类
class Animal{
String breed;
int age;
String sex;
public void eat() {
System.out.println("动物吃...");
}
public void sleep() {
System.out.println("动物睡...");
}
}
//子类
class Dog extends Animal{
String furColor;
public void run() {
}
//重写
@Override
public void eat() {
System.out.println("狗狗吃骨头...");
}
}
//子类
class Cat extends Animal{
String eyeColor;
//重写
@Override
public void eat() {
System.out.println("猫猫吃鱼...");
}
}
super关键字
子类对父类方法复用，然后叠加额外的功能代码
- super关键字的第一种用法：
在子类的方法中使用“super.”的形式访问父类的属性或方法
例如：super.父类属性; super.父类方法(); super.value; super.eat();
- super关键字的第二种方法：
在子类的构造方法的首行，使用super(); super(实参);调用父类构造方法
同一个子类的构造方法中，super()、this()不可同时存在
public class TestBasicSuper {
public static void main(String[] args) {
B b = new B();
b.printValue();
}
}
class A{
int value = 10;
}
class B extends A{
int value = 20;
public void printValue() {
int value = 30;
System.out.println(value);
System.out.println(this.value);
System.out.println(super.value);
}
}
public class TestArgs {
public static void main(String[] args) {
//new Son();
new Son(10);
}
}
class Father{
public Father() {
System.out.println("Father()无参构造执行了");
}
public Father(int a) {
System.out.println("Father()有参构造执行了");
}
}
class Son extends Father{
public Son() {
System.out.println("Son()无参构造执行了");
}
public Son(int a) {
super(a);
System.out.println("Son()有参构造执行了");
}
}
继承关系下的对象构建
继承关系下，构建子类对象时，一定先构造父类对象
由“父类的共性”+“子类的独有”，组成一个完整的子类对象
/**
* 继承中的对象构建
* 1、构造父类对象
* 2、初始化自身属性
* 3、执行自身构造方法的逻辑代码
*/
public class TestCreatClass {
public static void main(String[] args) {
C c = new C();
}
}
class A{
String fieldA = "A的属性";//1、加载属性
public A() {//2、执行构造方法中的逻辑代码
super();//默认存在，调用父类构造
System.out.println("A的构造方法执行了..."+fieldA);
}
}
class B extends A{
String fieldB = "B的属性";//1、加载属性
public B() {//2、执行构造方法中的逻辑代码
super();//默认存在，调用父类构造
System.out.println("B的构造方法执行了..."+fieldB);
}
}
class C extends B{
String fieldC = "C的属性";//1、加载属性
public C() {//2、执行构造方法中的逻辑代码
super();//默认存在，调用父类无参构造
System.out.println("C的构造方法执行了..."+fieldC);
}
}
继承关系下对象的构建流程
1、构建父类对象
2、初始化自身属性
3、执行构造方法中的逻辑代码
多态
概念：父类引用指向子类对象，从而引起多种状态
构造多态的前提：二者必须具有直接或间接的继承关系，父类引用指向子类对象，进而为多态做准备
父类引用只能调用父类中声明的属性和方法，不能调用子类独有的属性和方法
多态的应用场景：
使用父类作为方法，形参实现多态，实际传递子类对象使方法参数类型更加广泛
public class Vehicle {
String type;//类型
int speed;//速度
double price;//价格
public void run() {
System.out.println("一辆价值"+this.price+"RMB的，"+this.type+"正在以"+this.speed+"的速度行驶。");
}
}
public class Bicycle extends Vehicle{
String color;//颜色
public void run() {
System.out.println("一辆价值"+this.price+"RMB的，"+this.color+"颜色的"+this.type+"正在以"+this.speed+"的速度行驶");
}
}
public class Bus extends Vehicle{
int seatNum;//座位数
public void run() {
System.out.println("一辆价值"+this.price+"RMB的，"+this.seatNum+"个座位"+this.type+"正在以"+this.speed+"的速度行驶。");
}
}
public class Car extends Vehicle{
String brand;//品牌
public void run() {
System.out.println("一辆价值"+this.price+"RMB的，"+this.brand+"品牌的"+this.type+"正在以"+this.speed+"的速度行驶");
}
}
public class TestPloy {
public static void main(String[] args) {
Vehicle v = new Car();
v.type = "小汽车";
v.speed = 60;
v.price = 350000;
//v.brand = "宝马";父类不可以调用子类特有的属性 v.run();
Vehicle v1 = new Bus();
v1.type = "公交车";
v1.speed = 100;
v1.price = 1000000;
v1.run();
Vehicle v2 = new Bicycle();
v2.type = "自行车";
v2.speed = 10;
v2.price = 3000;
v2.run();//多态场景下，父类引用调用方法时，如果子类重写父类方法，优先调用子类重写后的方法
}
}
抽象（abstract）
父类：不够完整，不够具体，不该独立存在。如何解决？通过abstract修饰，意为抽象类
抽象类不能独立new对象
可以被子类继承，为子类提供共性属性和方法
可以声明引用，更纯粹的使用多态
抽象类构造方法作用：构建子类对象时，先构建父类对象，由“父类共性”+“子类独有”组成完整的子类
子类继承抽象类后，必须重写父类中所有的方法，
public abstract class Animal {//使用abstract修饰的类为抽象类，不能new对象（不能独立存在）
String breed;
int age;
String sex;
//子类继承用
public Animal() {
System.out.println("Animal构造被调用了");
}
//抽象方法
public abstract void eat();
public void sleep() {
System.out.println("动物睡");
}
}
public class Cat extends Animal{
@Override
//继承重写eat方法
public void eat() {
System.out.println("猫咪正在吃鱼");
}
}
public class Dog extends Animal{
public Dog() {
super();
System.out.println("Dog构造被调用了");
}
@Override
//继承重写eat方法
public void eat() {
System.out.println("狗狗正在吃骨头");
}
}
public class TestAnimal {
public static void main(String[] args) {
//Animal a = new Animal();//不能被创建实例，不该独立存在
Animal a = new Dog();//构建子类对象要先构建父类对象
a.eat();
a.sleep();
Animal a2 = new Cat();
a2.eat();
a2.sleep();
}
}
浙公网安备 33010602011771号