Day11（重写，多态，final，抽象类）

一、重写

1、方法重写的注意事项：

1、父类中私有的方法不能被重写

2、子类重写父类方法的时候，访问权限不能更低

要么子类重写的方法访问权限比父类的访问权限要高或者一样

建议：以后子类重写父类方法的时候，权限修饰符写一样就不会发生这样的问题

3、父类中静态的方法不能被重写，也就是说不能被Override修饰，因为静态的是属于类本身的东西

class OldPhone{

private String name;

public void call(String name){

System.out.println("打电话给："+ name)；

}

public static void play(){

System.out.println("玩俄罗斯方块");

}

class NewPhone extends OldPhone{

@override

public void call(String name){

// super.call(name);

System.out.println("玩王者荣耀");

}

public class ExtendsDemo1{

public static void main(String[] args){

NewPhone newPhone = new NewPhone();

newPhone.call("明旺");

}

2、继承Test

class A{

//将父类中的静态成员看作一个全局共享的，被所有的子类共享

public static int a =10;

public static void fun(){

Systenm.out.println("hello");

}

class B extends A{

public void fun(){

a = 200;

System.out.println(a);

}

public static void fun(){

System.out.println("world");

}

public class ExtendsDemo2{

public static void main(String[] args){

B b = new B();

System.out.println(b,a);

b.fun();

b.fun2();

System.out.println(b,a);

System.out.println(A,a);

}

二、final关键字

1、有些时候，我们不想让子类覆盖重写父类中的方法或者功能，只能让子类去使用

那怎么办呢？

针对这个情况，java提供了一个关键字：final

final：最终的意思。可以修饰类，成员变量，成员方法

class Fu{

public final void show(){

System.out.println("这是父类中的show方法");

}

class Zi extends Fu{

// @Override

// public void show(){

// System.out.println("这是子类中的show方法");

// }

}

public class ZiDemo{

public static void main(String[] args){

Zi zi = new Zi();

zi.show();

}

2、final的特点：

1）修饰类，类不能被继承

2）修饰成员变量，变量变常量，并且只能赋值一次，在构造方法完毕之前赋值即可

常量：

字面值常量

自定义常量：被final修饰变量变成自定义常量

3）final修饰成员方法：方法不能被重写

//无法从最终com.shujia.......Fu2进行继承

//final class Fu2{}

class Fu2{

int num = 10;

// final int num2 = 200;

final int num2;

// {

// num2 = 400;

// }

Fu2(){

num2 = 400;

}

class Zi2 extends Fu2{

public void show(){

num = 100;

System.out.println(num);

// num2 = 300;//无法为最终变量num2分配值

System.out.println(num2);

}

public class FinalDemo{

public static void main(String[] args){

Zi2 zi2 = new Zi2();

zi2.show();

}

3、面试题：final修饰局部变量

1）在方法内部，修饰基本数据类型的变量，变量只能赋值一次，不能发生改变

2）final修饰引用数据类型的变量呢？

引用的地址值不可以发生改变你，但是该对象的堆内存中的值是可以发生改变的

class Student{

int age = 10;

}

public class FinalDemo2{

public static void main(String[] args){

int x = 100;

x = 300;

System.out.println(x);

final int y = 200;

// y = 400; //无法为最终变量y分配值

System.out.println(y);

Student student = new student();

System.out.println(student.age);

final Student s2 = new Student();

Syatem.out.println(s2.age);

s2.age = 1000;

System.out.println(s2.age);

System.out.println("========================================")'

// s2 = new Student();// 无法为最终变量s2分配值

}

三、多态

1、多态：某一事物，在不同时刻表现出来的不同状态

举例：

水：

固态、液态、气态

固态是水、液态的也是水、气态的水也是水

水果：

波罗蜜、香蕉、榴莲

菠萝蜜是水果、香蕉也是水果、留恋也是水果

水果是波罗蜜//反过来说是有问题的

动物：

狗、猫、虎、大象

狗屎动物，这么说是没问题的

动物是狗，这么说是不可以

说了这么多，总结出一个思想，这个思想叫做：多态

通过观察例子发现，要想有多态，就必须要有继承，继承是多态的前提

多态的前提：

1）要有继承关系

2）要有方法的重写

其实没有重写也是可以的，但是不重写就没有意义

动物都有吃这个方法，但是每个具体的动物吃的实现不一样，表现出不同动物的特有属性

3）要有父类的引用指向子类对象

父类名 f = new 子类名(....);

多态访问成员的特点：

1）成员变量

编译看左，运行看左

2）构造方法

创建子类对象的时候，先访问父类中的构造方法，对父类的数据进行初始化

3）成员方法

编译看左，运行看右

因为成员方法存在重写，所以访问看右边

4）静态成员方法

编译看左，运行也看左

由于被static修饰的成员都是与类相关的，这里不是重写，所以运行的时候，访问的还是左边的

class Fu3{

int num = 100;

public void show(){

System.out.println("这是父类中show()方法");

}

public static void fun(){

System.out.println("这是父类中的静态fun方法");

}

class Zi3 extends Fu3{

int num = 1000;

@Override

public void show(){

System.out.println("这是子类中的show()方法");

}

public void show2(){

System.out.println("这子类特有的方法1");

}

public static void fun(){

System.out.println("这是子类中的静态fun方法");

}

public class PolymorphicDemo1{

public static void main(String[] args){

//多态创建了一个对象

Fu3 f = new Zi3();

System.out.println(f.num);

f.show();//这是子类中的show方法

f.fun();

}

2、多态的前提：（三个缺一不可）

1）要有继承的关系

2）子类要重写父类中的方法

3）父类的引用指向子类对象

多态的弊端：

多态无法使用父类特有的方法

class Father{

public void show(){

System.out.println("这是父类中的show方法");

}

class Son extends Father{

@Override

public void show(){

System.out.println("这是子类中的show方法");

}

public void show2(){

System.out.println("这是子类中特有的方法");

}

public class PolymorphicDemo2{

public static void main(String[] args){

Father f = new Son();

f.show();

//需求：我现在就想调用父类中的show方法，怎么办？

// f.show();

// f.show2();

}

3、多态的弊端：

多态无法访问父类中的方法名一样的方法

1）我就想使用父类中的方法，能不能用，能，不使用多态

2）如果我想使用子类中的特有方法，还必须使用多态，咋办？

a.就不使用多态，创建子类对象然后调用方法

但是在我上一个例子上，再次创建对象，还会在堆内存中开辟空间，很有可能会造成资源浪费

b.以我们目前的知识，我们还不会，但是我们想一想之前的数据类型

将子类看成一个小的类型，将父类看成一个很大的类型，现在想要用小的类型中的方法

我们应该要将大的类型转成小的类型，在我们之前的做法是用强制类型转换

如果在继承关系，也有类似这样的关系就好了

java替我们考虑到这样的问题，提供了一个技术给我们使用：向下转型

将父类的引用强制转换成子类的引用

子类名变量名 = (子类类名)父类的引用;

对象之间转型的问题：

1、向上转型：

Fu f = new Son();

2、向下转型

Son s = (Son)f;

int a = 10;

byte b = (byte)a;

向下转型需要注意的一个问题：

需求转型的类与父类引用存在继承关系，并且一开始创建多态的时候，使用的是该类

class Father2{

public void show(){

System.out.println("这是父类中的show方法");

}

class Son2 extends Father2{

@Override

public void show(){

System.out.println("这是子类中的show方法");

}

public void show2(){

System.out.println("这是子类中特有的方法");

}

class Demo extends Father2{}

public class PolymorphicDemo3{

public static void main(String[] args){

//多态创建对象

Father2 f = new Son2();

// f.show();

// 将父类的引用进行向下转型

// 子类名变量名 = (子类类名)父类的引用;

Son2 s = (Son2)f;

s.show2();

Demo d = (Demo)f;

d.show();//ClassCastException

}

多态的好处有哪些？

1、多态可以使代码的扩展性很好（这是由继承所保证的）

2、多态可以使代码的维护性很好（这是由多态保证的）

class Animal{

String name;

int age;

Animal(){

}

public Animal(String name,int age){

this.name = name;

this.age = age;

}

public void sleep(){

System.out.println("睡觉");

}

public void eat(){

System.out.println("吃");

}

class Dog extends Animal{

public Dog(){

}

public Dog(String name,int age){

this.name = name;

this.age = age;

}

@Override

public void eat(){

System.out.println("狗吃肉");

}

@Override

public void sleep(){

System.out.println("狗侧着睡");

}

class Cat extends Animal{

public Cat(){

}

public Cat(String name,int age){

this.name = name;

this.age = age;

}

@Override

public void eat(){

System.out.println("猫趴着睡");

}
}

class Panda extends Animal{

public Panda(){

}

public Panda(String name,int age){

super(name,age);

}

@Override

public void eat(){

System.out.println("熊猫吃竹子");

}

@Override

public void sleep(){

System.out.println("熊猫随意着睡");

}

class Tiger extends Animal{

public Tiger(){

}

public Tiger(String name,int age){

super(name,age);

}

@Override

public void eat(){

System.out.println("老虎吃鸡");

}

@Override

public void sleep(){

System.out.println("老虎躺着睡");

}

class AnimalTool{

private AnimalTool(){

}

// //对狗的吃饭和睡觉进行调用

// public static void UseDog(Dog dog){

// dog.eat();

// dog.sleep();

// }

// 对猫的吃饭和睡觉进行调用

// public static void useCat(Cat cat){

// cat.eat();

// cat.sleep();

// }

// public static void usePanda(Panda panda){

// panda.eat();

// panda.sleep();

// }

// Animal animal = new Dog("小白",3);

// Animal animal = new Tiger("小虎",18)/t1;

public static void useAnimal(Animal animal){ //Animal animal = new Panda("圆圆",3);

//利用了多态访问成员方法的特点，编译看左，运行看右，实际调用的是子类对象中的方法

animal.eat();

animal.sleep();

}

public class CatDogDemo{

public static void main(String[] args){

//我想养一只狗

Dog d1 = new Dog("小白",3);

// d1.eat();

// d1.sleep();

// useDog(d1);

// 工具类调用

// AnimalTool.useDog(d1);

AnimalTool.useAnimal(d1);

//我还想养一只狗

Dog d3 = new Dog("旺财2",4);

d3.eat();

d3.sleep();

// useDog(d3);

// AnimalTool.useDog(d3);

//我觉得没new完一次对象的时候，都要写一遍eat()和sleep()

//用方法改进

//我想养一只猫

Cat c1 = new Cat("Tom",2);

// useCat(c1);

Cat c2 = new Cat("奶茶",3);

// useCat(c2);

Cat c3 = new Cat("大白",4);

// useCat(c3);

// 如果我现在不想养猫和狗了，我想养熊猫

// 如果想养熊猫，第一步我们应该先创建这个类

// 第二步写一个熊猫的方法

// 但是将来，我们还要养老虎，狮子，豹子等等

// 这些动物按照上面的实现，是不是都要写一个类，然后再测试类中写一个方法，当我的动物特别多的时候

// 这个类的方法会非常的多，显得非常臃肿

// 那这时候如何改进呢？使用工具类改进

Panda p1 = new Panda("团团",2);

// AnimalTool.usePanda(p1);

//但是，今后工具类理论上创建后，还能被修改吗？

//正常来说，工具类是不能随意改动的，而你现在要想养一只新的动物，就要往工具类中加一个方法，这样虽然能实现，但是不符合规范，因为工具类一旦定义不能随意改动

//改进工具类的做法

//使用多态改进

Panda p2 = new Panda("圆圆",3);

AnimalTool.useAnimal(p2);

//养一只老虎

Tiger t1 = new Tiger("小虎",18);

AnimalTool.useAnimal(t1);

}

//对狗的吃饭和睡觉进行调用

// public static void useCat(Cat cat){

// cat.eat();

// cat.sleep();

// }

// public static void usePanda(Panda panda){

// panda.eat();

// panda.sleep();

// }

}

4、向下转型猫狗案例

class Animal2{

public void eat(){

System.out.println("吃");

}

class Dog2 extends Animal2{

@Override

public void eat(){

System.out.println("狗吃肉");

}

public void lookDoor(){

System.out.println("看门");

}

class Cat2 extends Animal2{

@Override

public void eat(){

System.out.println("猫吃鱼");

}

public void catchMouse(){

System.out.println("猫捉老鼠");

}

public class PolymorphicDemo4{

public static void main(String[] args){

//以多态的形式创建一个对象

Animal2 a = new Dog2();

a.eat();

// a.lookDoor();

// 向下转型访问子类中特有的方法

Dog2 d = (Dog2) a;

d.eat();

d.lookDoor();

//ClassCasException类转换异常

Cat2 c = (Cat2) a;//此刻内存中还是一个Dog2的对象

c.catchMouse();

}

5、不同地方饮食文化不同的案例

Person

eat()

SouthPerson

eat()

NorthPerson

eat()

class Person{

public void eat(){

System.out.println("吃")；

}

class SouthPerson extends Person{

@Override

public void eat(){

System.out.println("南方人吃米饭");

}

public void playMaJiang(){

System.out.println("南方人打麻将");

}

class NorthPerson extends Person{

@Override

public void eat(){

System.out.println("北方人吃面食");

}

public void bath(){

System.out.println("北方人搓澡");

}

public class PolymorphicDemo5{

public static void main(String[] args){

//多态创建南方人对象

Person p = new SouthPerson();

p.eat();

// p.playMaJiang();

//向下转型

SouthPerson sp = (SouthPerson) p;

sp.eat();

sp.playMaJiang();

//多态创建北方人对象

Person p2 = new NorthPerson();

p2.eat();

// p2.bath();

//向下转型

NoethPerson np = (NorthPerson) p2;

np.eat();

np.bath();

}

四、抽象类

1、抽象类的表述：

我们之前所说的猫，狗，猪，熊猫，老虎等等都是动物具体的例子，而动物本身是一个抽象的概念

但是回想一下我们之前都是将动物写成了一个具体的，而类又可以创建对象，但是实际上抽象的东西本身不应该被实例化，并且动物中吃的方法应该也不是一个具体的表现，以及所有动物共同拥有的方法在动物中应该改都是抽象的表现，我们今天之后，我们把一个不具体的功能，叫做抽象方法，而如果一个类中由抽象方法，我们就把这个类称之为抽象类

抽象类的特点：

1）抽象类和抽象方法都要用一个关键字修饰：abstract

修饰一个类放在class的前面

举例：abstract class Animal3{}

修饰一个方法一般是放在权限修饰符后面

定义一个抽象的show方法

举例：public abstract void show();

2）由抽象方法一定要是抽象类，抽象类不一定要有抽象方法，具体的类中不能有抽象方法，抽象类中既可以存在抽象方法，也可以存在有方法体的方法

3）抽象类不能被实例化

既然不能被实例化，那写在抽象类中的方法如何被调用呢？

抽象类如何创建呢？

通过多态的形式，使用具体的子类去实例化调用方法，专业术语称之为：抽象多态

4）如果继承抽象类的是一个具体的子类，需要重写该抽象类中所有的抽象方法，如果继承抽象的也是一个抽象类，可以不去重写父类中的抽象方法，也可以选择性的去重写

//定义了一个抽象类，叫Animal3

abstract class Animal3{

//注意：

//抽象方法没有方法体{}，连大括号都没有，直接以分号结尾

//java：抽象方法不能有主体

//public abstract void eat(){}

public abstract void eat();

public abstract void drink();

}

class Dog3 extends Animal3{

@Override

public void eat(){

System.out.println("狗吃肉");

}

@Override

public void drink(){

System.out.println("狗喝水")；

}

//class Demo2{

// public abstract void fun1();

//}

abstract class Demo2{

public abstract void fun();

public abstract void fun2();

}

abstract class Demo3 extends Demo2{

@Override

public void fun(){

System.out.println("抽象类Demo3中重写了fun方法");

}

public class AbstractDemo1{

public static void main(String[] args){

//java:com.shujia.wyh.day11.Demo2是抽象的无法实例化

//Demo2 demo2 = new Demo2();

//利用具体子类多态形式创建对象

//抽象多态的形式

Animal3 a = new Dog3();

a.eat();

a.drink();

}

2、抽象类的成员的特点：

成员变量：

既可以是变量也可以是常量

构造方法：

可以存在构造方法，我们上一个程序中，才总结出抽象类不能被实例化，这里构造方法意义是什么？

我们之前在继承中还说过要想初始化子类，必须先初始化父类，所以这里的构造方法是提供初始化父类的作用

成员方法：

可以是抽象方法，但是具体的子类必须要重写该方法

也可以不是抽象方法，提高代码的复用性

abstract class Animal4{

int a = 20;

final int b = 100;

Animal4(){

System.out.println("这是Animal4中无参构造方法");

}

public abstract void eat();

public void show(){

System.out.println("父类中不是抽象方法的show");

}

class Cat4 extends Animal4{

@Override

public void eat(){

System.out.println("猫吃鱼");

}
}

public class AstractDemo2{

public static void main(String[] args){

Animal4 a = new Cat4();

System.out.println(a.a);

System.out.println(a.b);

a.eat();

a.show();

}

3、一个类如果没有抽象方法可不可以定义为抽象类？

可以

如果可以有什么意义？

橙汁、水、牛奶这些东西都有一个共同的特点，都是液体，我们把这些相同的行为归结成一个类

假设就叫做液体

至于后面有没有抽象方法，取决于这些东西有没有相同的功能，只是说有这相同的本质，没有实际相同的行为，我们只定义一个抽象类

不写抽象方法也是可以的

1）抽象类中可以没由抽象方法

2）抽象类不能被实例

抽象类中可以存在哪些关键字？

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

private

static

final

abstract class YeTi{

// Java中的所有的类都有一个共同的父类：Object

// YeTi(){

// //super()

// }

// abstract可以和public关键字共存

public abstract void show();

// private和abstract关键字冲突

// private abstract void show2();//Java：非法的修饰符组合：abstract和private

// static和abstract关键字冲突

// static abstract void show3();//java:非法的修饰符组合：abstract和static

// final和abstract关键字冲突

// final abstract void show4();//java:非法的修饰符组合：abstract和final

}

public class AbstractDemo3{

public static void main(String[] args){

}

4、抽象类改进猫狗案例

abstract class Animal5{

//定义一个吃饭的抽象方法，不给出具体的实现

public abstract void eat();

//定义一个睡觉的抽象方法，不给出具体的实现

public abstract void sleep();

}

//alt+enter

class Dog5 extends Animal5{

@Override

public void eat(){

System.out.println("狗吃肉");

}

@Override

public void sleep(){

System.out.println("狗侧着睡");

}

class Cat5 extends Animal5{

@Override

public void eat(){

System.out.println("猫吃鱼");

}

@Override

public void sleep(){

System.out.println("猫趴着睡");

}

public class AbstractTest1{

public static void main(String[] args){

//抽象多态创建一个对象

Animal5 a = new Dog5();

a.eat();

a.sleep();

//抽象多态创建第二个对象

Animal5 c = new Cat5();

c.eat();

c.sleep();

}

5、老师案例

具体的事物：十五期老师，十四期老师

共性：姓名，年龄，讲课。

abstract class Teacher{

private String name;

private int age;

public int age;

public Teacher(){

}

public Teacher(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;

}

public abstract void teach();

}

class FourteenTeacher extends Teacher{

public FourteenTeacher(){

}

public FourteenTeacher(String name,int age){

super(name,age);

}

@Override

public void teach(){

System.out.println("教Hive知识");

}

class FifteenTeacher extends Teacher{

public FifteenTeacher(){

}

public FifteenTeacher(String name,int age){

super(name,age);

}

@Override

public void teach(){

System.out.println("教JavaSE");

}

public class AbstractTest2{

public static void main(String[] args){

//多态创建14期老师对象

Teacher t1 = new FourteenTeacher("志凯",20);

t1.teach();

//多态创建15期老师对象

Teacher t2 = new FifteenTeacher("小虎",18);

t2.teach();

}

6、学生案例

具体事务：14期学员，15期学员

共性：姓名，年龄，班级，学习，吃饭

abstarct class Studnet2{

private String name;

private int age;

public Student2(){

}

public Student2(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;

}

//将学习定义为抽象方法

public abstract void study();

//吃饭是具体的方法

public void eat(){

System.out.println("吃米饭");

}

class FifteenStudent extends Student2{

public FifteenStudent(){

}

public FifteenStudent(String name,int age){

super(name,age);

}

@Override

public void study(){

System.out.println("学习JavaSE");

}

class FourteenStudent extends Student2{

public FourteenStudent(){

}

public FourteenStudent(String name,int age){

super(name,age);

}

@Override

public void study(){

public static void main(String[] args){

//多态创建第一个对象

Student2 s1 = new FifteenStudent("周家祥",18);

s1.study();

Student2 s2 = new FourteenStudent("朱佳乐",19);

s2.study();

}

7、假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资

经理也是员工，除了含有员工的属性外，另外还有一个奖金属性

请使用继承的思想设计出员工类和经理类，需求类中提供必要的方法进行属性访问

分析：

普通员工：

成员变量：姓名，工号，工资

成员方法：工作（敲代码）

经理：

成员变量：姓名，工号，工资，奖金

成员方法：工作（做PPT）

abstract class Staff{

private String name;

private String id;

private int salary;

public Staff(0{

}

public Staff(String name,String id,int salary){

this.name = name;

this.id = id;

this.salery = salery;

}

public String getName(){

return name;

}

public void setName(String name){

this.name = name;

}

public String getld(){

return id;

}

public void setld(String id){

this.id = id;

}

public int getSalay(){

return salary;

}

public void setSalary(int salary){

this.salary = salary;

}

public abstract void work(){

}

class CommonStaff extends Staff{

public CommonStaff(){

}

public CommonStaff(String name,String id,int salary){

super(name,id,salary);

}

@Override

public void work(){

System.out.println("敲代码")；

}

class Manager extends Staff{

//特有的属性奖金

private int bonus;

public Manager(String name,String id,int salary,int bonus){

super(name,id,salary);

this.bonus = bonus;

}

@Override

public void work(){

System.out.println("做PPT");

}

public class AbstractTest4{

public static void main(String[] args){

//创建第一个对象

Staff s1 = new CommonStaff("小虎","KZ0080",100000);

s1.work();

//创建第二个对象

Staff s2 = new Manager("周家祥","SJ0030",200000,1000000);

s2.work();

}

Day11（重写，多态，final，抽象类）相关推荐

Eclipse,静态,继承,封装,this,super,重写,重载,多态,final,冒泡排序,选择排序,抽象类,接口,内部类
文章目录 Eclipse工具中java项目的工程结构静态代码块的书写格式静态代码块,构造代码块,构造方法的优先级 static关键字的特点封装的概念 private关键字的特点面向对象思想特点 ...
java学习笔记day09 final、多态、抽象类、接口
java学习笔记day09 思维导图 final . 多态 . 抽象类 . 接口 (都很重要) 一.final 二.多态多态中的成员访问特点⭐ [P237] 多态的好处 [P239] 多态的弊端向 ...
java 接口抽象类继承重载重写多态
4.1 抽象类在面向对象领域由于抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能实例化的. 同时,抽象类体现了数据抽象的思想,是实现多态的一种机制.它定义了一组抽象的方法, ...
【Java SE】继承；组合；向上转型；动态绑定；方法重写；静态绑定；多态；抽象类；接口；
面向对象编程文章目录 1. 包 1.1 导入包中的类 1.2 静态导入 1.3 将类放到包中 1.4 包的访问权限控制 1.5 常见的系统包 2. 继承 2.1 语法规则 2.2 protected ...
day11 Java 面向对象 final 多态
文章目录一.final 关键字二.多态 (polymorphic) 1.基本 2.多态访问成员特点 3.向上转型和向下转型 3.instanceof 关键字 4.多态访问成员特点五.练习总结 ...
14 面对对象（多态；抽象类；接口）
文章目录多态(动态绑定机制) 多态的概述多态的成员访问特点多态的好处和弊端向上转型和向下转型多态内存图猫狗案例多态版多态中的题目分析题抽象类抽象类的概述抽象类的成员特点抽象类的案 ...
2020.4.22课堂笔记（继承、多态、抽象类、抽象方法）
在继承的情况下,子类的方法满足以下条件: 1.方法名相同 2.参数列表相同 3.返回值类型相同,或者是父类返回值类型的子类 4.访问修饰符的权限不能小于父类方法 5.抛出的异常不能大于父类(严于) 多 ...
【26天高效学完Java编程】Day11：继承、抽象类、模板设计模式详解
本专栏将从基础开始,循序渐进,由浅入深讲解Java的基本使用,希望大家都能够从中有所收获,也请大家多多支持. 专栏地址:26天高效学习Java编程相关软件地址:软件地址所有代码地址:代码地址如果 ...
面向对象——多态、抽象类、接口
多态概念:父类类型引用指向子类对象(多态的第一种形式) 多态的前提是继承语法: 父类类名对象名 = new 子类类名(); 1.多态的类型转换: 1.1自上类型转换子类型转成父类型(dog ...
9-java学习-多态、抽象类、接口-案例代码
9-java学习-多态.抽象类.接口-案例代码一.多态 1.多态:一种事物,在不同时刻所表现出的不同状态. 多态的前提要有继承.没有继承,那么动态就无从谈起多态要有方法重写,如果没有方法重 ...

Day11（重写，多态，final，抽象类）

Day11（重写，多态，final，抽象类）相关推荐

最新文章

热门文章