JAVA自学笔记09

JAVA自学笔记09

1、子类的方法会把父类的同名方法覆盖（重写）

2、final:

1)可修饰类、方法、变量

2)修饰类时：此时该类变为最终类，它将无法成为父类而被继承

3)修饰方法时：该方法将无法被重写

4)变量为常量，其值不可被改变

修饰引用类型时：引用类型的地址值不能变但其成员变量（堆内存的值）等是可以变的

5）初始化时机：

被final修饰的变量只能赋值一次

在构造方法完毕前修饰变量，避免其被构造方法改变（非静态的常量）

3、多态

1）某一个事物，在不同时刻表现出不同的状态

2）前提与体现：有继承关系、有方法重写、有父类引用指向子类对象

即格式为 父类名 父类对象名 = new 子类名（）;

3)成员访问特点：

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

②成员变量：编译运行都看左边的类，以父类所有的成员变量为准

③成员方法：编译看左边，运行看右边（子类重写父类同名方法）

④静态方法：编译看左边，运行看左边（不存在方法重写）

4）优点：

①提高代码维护性

②提高代码扩展性

5）弊端：不能使用子类特有的功能

解决：①创建子类对象调用相关方法即可

②（本方式较好，因为没有再创建新的对象，节约内存。向下转型，要求该f必须是能够转换为Zi的）使用多态后，将创建的父的引用赋值给子类的引用，即

Zi z=(Zi)f;//使用了强制类型转换

向上转型：

Fu f=new Zi();

6）多态继承中的内存图解



7）多态中的对象变化内存图解

异常：ClassCastException 类不匹配，易在向下转型中出现



8）多态多层继承时

子类中有和父类中一样的方法，就重写

子类中没有和父类中出现过分方法，该方法就被继承过来

@例题1：看程序写结果

class A {
    public void show() {
        show2();
    }
    public void show2() {
        System.out.println("我");
    }
}
class B extends A {
    /*
    public void show() {
        show2();
    }
    */

    public void show2() {
        System.out.println("爱");
    }
}
class C extends B {
    public void show() {
        super.show();
    }
    public void show2() {
        System.out.println("你");
    }
}
public class DuoTaiTest4 {
    public static void main(String[] args) {
        A a = new B();
        a.show();//多态继承，运行看右边，B类由A类继承了自己没有的show()，
        //show()调用show2()，根据就近原则，输出“爱”

        B b = new C();//运行看右边，调用super.show（）即B类的show()，接
        //着调用show2()，由就近原则，输出“你”
        b.show();
    }
}

例如:

class Fu{
public int num=100；
public void show(){
System.out,println("show fu");
}
public static void Function(){
System.out,println("Fuction fu");
}
}
class Zi extends Fu{
public int num=1000；
public int num2=200；
public void show(){
System.out,println("show zi");
}
public void method(){
System.out,println("method zi");
}
public static void Function(){
System.out,println("Fuction zi");
}
}
class Demo{
public static void main(String args[]){
Fu f = new Zi();
System.out,println(f.num);//100
System.out,println(f.num2);//找不到符号
f.show();//show zi
f.method();//报错：找不到符号
f.Funcction();//Fuction zi
}
}

2、抽象类

1）在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

2）特点：

①抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名{}

public abstract void 方法名();//省去花括号

②抽象类不一定有抽象方法但有抽象方法的类一定是抽象类

③抽象类不能实例化，不能创建关于抽象类的对象，但它有构造方法 。抽象类的子类要么也是抽象类，要么重写抽象类中所有的抽象方法。进而通过多态的方式创建对象间接实现实例化：

抽象类名 对象名=new 继承抽象类的类构造方法名();

3）抽象类的成员的特点：

①成员变量：可以是变量也可以是常量

②构造方法：有构造方法，但不能实例化，它是用作子类访问父类数据时进行初始化的

③成员方法：可以有抽象方法，限定子类必须完成某几种特定的功能；也可以有非抽象方法被子类所继承，以提高代码复用性

4）抽象类的注意事项：

一个类若无抽象方法，可不可以定义为抽象类？如果可以，有什么意义？

可以，这样做的意义是不允许创建对象

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

private 冲突

final 冲突

static 无意义

3、接口

1）利用接口定义额外功能

2）接口特点：

①格式：interface 接口名{}

类实现接口：class 类名 implements 接口名{}

//定义动物培训接口
interface AnimalTrain{
public abstract jump();//定义抽象方法
}
class Cat implement AnimalTrain{
public void jump(){
System.out.println("猫跳");
}
}
class Demo{
public static void main(String args[]){
AnimalTrain at=new Cat();
at.jump();//猫跳
}
}

②接口不能直接实例化,要通过多态

具体类多态、抽象类多态、接口类多态（最常用）

③接口的子类：要么是抽象类，要么重写接口中所有的抽象方法

3）接口的成员的特点

①一般来说：接口名+Impl这种格式是接口的实现类的命名规则

②接口的成员变量默认为常量，即默认修饰符为public static final

③ 没有构造方法 。所有的类都默认继承一个类Object(类层次结构的根类、每个类都要用Object作为父类)

④接口成员方法不能带方法体，即接口成员方法必须是抽象的且必须是public的，

默认修饰符public abstract

4、

1）类与类的关系：继承关系，只能是单继承，但可以多层继承

2）类与接口：类实现接口，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3）接口与接口

继承关系，可以单继承，也可以多继承

4）抽象类与接口的区别

①成员区别：常量、变量、抽象方法、非抽象方法/常量、抽象方法

②关系区别：见1）~3）

③抽象类被继承体现的是“is a”的关系，体现共性

接口实现的是“”