1.
进父类 打印出y x 进子类 打印出 y z
1.子类继承父类,程序执行的过程中先加载用父类(即x类)
2.java程序执行时先加载全局变量(即父类里面的y类)
}
}
2final的用法:
final可以修类,该类不能继承
fianl可以修饰成员方法,该方法不能被重写
final可以变量(成员/局部变量),这个时候变量就变成了一个常量!(常用)(所以不能再被修改)
常量的分类:
字面值常量:
"hello",'A',100....
自定义常量:
final int num = 10 ;
3.子类将父类中的方法覆盖掉,篡改了父类中方法.有时候可能不想子类去重写父类中 方法,java就提供了一个关键字:
final:最终的,终态的!(表示:无法更改的)
4.多态:指的是一个事物,在不同时刻状态的一个体现!
水:固态,气态,液态;
Dog d = new Dog();//创建了一个狗类的对象
Animal a = new Dog();狗是一个动物
= new cat();
4.1多态的前提条件
1)必须有继承关系
2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)
动物类:吃和睡的功能,子类重写父类的方法的原因:使用子类中有具体的功能..
3)父类的引用指向子类对象
继承的时候:使用子类的:Zi z = new Zi() ;
Fu f = new Zi() ;将f代表的父类引用指向堆内存的子类的对象!
向上转型!
4.2多态的成员访问特点
成员变量:
编译看左,运行看左!
非静态成员方法:
编译看左,运行看右
子类中的方法会覆盖掉父类中的方法
静态的成员方法:
编译看左边,运行看左边
(静态和类有关系)
构造方法:始终是给对象进行初始化的!..
4.3多态的弊端
子类只能使用父类的功能:不能使用子类中特有的功能!
要想使用子类具体功能
1)创建子类对象
2)向下转型:将父类的引用强制转换为子类对象
Fu f = new Zi() ;向上转型
Zi z = (Zi)(f) ;//向下转型
}
4.4多态的好处
提高了代码的维护性(由继承保证)
提高了代码的扩展性(由多态的保证)
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Y {
Y() {
System.out.print("Y");
}
}
//测试类
public class Z extends X{
Y y = new Y();
Z() {
// super();
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
//YXYZ
进父类 打印出y x 进子类 打印出 y z
1.子类继承父类,程序执行的过程中先加载用父类(即x类)
2.java程序执行时先加载全局变量(即父类里面的y类)
}
}
2final的用法:
final可以修类,该类不能继承
fianl可以修饰成员方法,该方法不能被重写
final可以变量(成员/局部变量),这个时候变量就变成了一个常量!(常用)(所以不能再被修改)
常量的分类:
字面值常量:
"hello",'A',100....
自定义常量:
final int num = 10 ;
3.子类将父类中的方法覆盖掉,篡改了父类中方法.有时候可能不想子类去重写父类中 方法,java就提供了一个关键字:
final:最终的,终态的!(表示:无法更改的)
class F{
final public void show(){
System.out.println("这是绝密文件,任何人都不能更改");
}
}
class S extends F{
// public void show(){
// System.out.println("我想更改。。。");
//}//若不注释掉,会报错,因为不允许更改
}
public class ExtendsDemo2 {
public static void main(String[] args) {
S s = new S();
s.show();//输出:这是绝密文件,任何人都不能更改
}
}
4.多态:指的是一个事物,在不同时刻状态的一个体现!
水:固态,气态,液态;
Dog d = new Dog();//创建了一个狗类的对象
Animal a = new Dog();狗是一个动物
= new cat();
4.1多态的前提条件
1)必须有继承关系
2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)
动物类:吃和睡的功能,子类重写父类的方法的原因:使用子类中有具体的功能..
3)父类的引用指向子类对象
继承的时候:使用子类的:Zi z = new Zi() ;
Fu f = new Zi() ;将f代表的父类引用指向堆内存的子类的对象!
向上转型!
4.2多态的成员访问特点
成员变量:
编译看左,运行看左!
非静态成员方法:
编译看左,运行看右
子类中的方法会覆盖掉父类中的方法
静态的成员方法:
编译看左边,运行看左边
(静态和类有关系)
构造方法:始终是给对象进行初始化的!..
4.3多态的弊端
子类只能使用父类的功能:不能使用子类中特有的功能!
要想使用子类具体功能
1)创建子类对象
2)向下转型:将父类的引用强制转换为子类对象
Fu f = new Zi() ;向上转型
Zi z = (Zi)(f) ;//向下转型
class Father{
public void show() {
System.out.println("show Father...");
}
}
class Son extends Father{
public void method(){
System.out.println("method Son...");
}
public void show(){
System.out.println("show Son.....");
}
}
public class DuotaiDemo2 {
public static void main(String[] args) {
Father f = new Son();
f.show();
//f.method();method()是子类特有的功能
//向下转型
Son s = (Son)f;
s.method();
s.show();
}
}
猫狗案例多态版
class Animal3{
public void eat(){
System.out.println("饿了就吃饭");
}
}
class Cat3 extends Animal3{
public void eat(){
System.out.println("猫吃鱼");
}
public void playGame(){
System.out.println("猫玩游戏");
}
}
class Dog3 extends Animal3{
public void eat(){
System.out.println("狗吃骨头");
}
public void lookDoor(){
System.out.println("狗看门");
}
}
public class CatandDog {
public static void main(String[] args) {
Animal3 a = new Cat3();
a.eat();
//向下转型
Cat3 c3 = (Cat3)a;
c3.eat();
c3.playGame();
}
}
4.4多态的好处
提高了代码的维护性(由继承保证)
提高了代码的扩展性(由多态的保证)
class Fu{
public int num = 20;
public Fu(){}
public void show(){
System.out.println("show Fu");
}
static void method(){
System.out.println("method Fu");
}
}
class Zi extends Fu{
int num = 20;
public Zi(){}
public void show(){
System.out.println("show Zi");
}
public static void method() {
System.out.println("show method");
}
}
public class DuotaiDemo {
public static void main(String[] args) {
Fu f = new Zi();//父类引用指向子类对象
System.out.println(f.num);//非静态方法 编译看左 运行看右 20
f.show();// show zi
f.method();//静态方法 编译看左 运行看左 method Fu
}
}class Animal{
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼。。。");
}
public void sleep(){
System.out.println("猫趴着睡觉");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
public void sleep(){
System.out.println("狗躺着睡觉");
}
}
//动物工具类
class AnimalTool{
private AnimalTool(){}
public static void useAnimal(Animal a){//因为静态方法不需要被实例化 直接传参数
a.eat();
a.sleep();
}
}
//测试类
public class DuotaiDemo1 {
public static void main(String[] args) {
Cat c1 = new Cat();
Cat c2 = new Cat();
Cat c3 = new Cat();
AnimalTool.useAnimal(c1);
AnimalTool.useAnimal(c2);
AnimalTool.useAnimal(c3);
}
}