Day 08Java基础学习笔记

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Day 08Java基础学习笔记相关的知识,希望对你有一定的参考价值。

继承extends(也叫扩展)

多个类中存在相同的属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。

通过extends关键字可以实现类的继承
    class 子类名 extends 父类名{}

继承的案例

创建一个Person类,定义两个功能吃饭、睡觉,再创建学生类、教师类,继承Person类,再定义两个自己独有的功能
创建Persen类
public class Person {
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
//创建子类学生类继承Person类
public class Student extends Person {
    public void play(){
        System.out.println("打游戏");
    }
}
//创建Teacher类继承Person类
public class Teacher extends Person {
    public void teach(){
        System.out.println("教书");
    }
}
//创建测试类,对继承进行测试
public class PersonExtends {
    public static void main(String[] args) {
        Student st = new Student();
        st.eat();   //用学生类调用继承方法
        st.play();  //调用自己的方法
        Teacher t =new Teacher();
        t.sleep();
        t.teach();
    }
}

继承的好处

  • 提高了代码的复用性:多个类的相同成员可以放到一个类中

  • 提高了代码的维护性:如果功能的代码需要修改,修改一处即可,继承的类中自动都被修改了

  • 让类与类之间产生了关系,是多态的前提

Java中继承的特点

Java只支持单继承,不支持多继承

即一个类只能有一个直接父类,不可以有多个直接父类

    正确写法:class Sub extends Demo{}
    错误写法:class Sub extends Demo1,Demo2{}
Java支持多层继承
    class A{}
    class B extends A{}
    class C extends B{}
    例
    //
    public class Grandfather {
        public void show(){
            System.out.println("grandfather");
        }
    }
    public class Father extends Grandfather {
        public void method(){
            System.out.println("father");
        }
    }
    public class Son extends Father {
        public void function(){
            System.out.println("son");
        }
    }
    //测试类
    public class GrandfatherTest {
        public static void main(String[] args) {
            Son s = new Son();
            s.function();
            s.method();
            s.show();
        }
    }

Java中继承的注意事项

  1. 子类只能继承父类中所有非私有的成员(成员变量、成员方法)
  2. 子类不能父类的的构造方法,但可以同super关键字去访问父类构造方法
  3. 不要为了部分功能去继承,如果有两个类A,B,只有他们符合A是B的一种或者B是A的一种,就可以考虑使用继承

继承中成员变量的关系

案列演示:
//创建父类定义成员变量
public class Field {
    int num = 10;
    public void method(){
        System.out.println(num);
    }
}
//创建子类继承父类,并定义与父类同名成员变量
public class FieldExtends extends Field {
    int num = 15;
    public void show(){
        System.out.println(num);
    }
    //在子类中定义新的方法,在方法内再定义与父类成员变量同名变量
    public void function(){  
        int num = 5;
        System.out.println(num);
    }
}
//测试类
public class FieldTest {
    public static void main(String[] args) {
        FieldExtends fe = new FieldExtends();
        fe.show();  // 15
        fe.function();   // 5
        fe.method();   //10
    }
}
通过案列可以知道在子类中访问一个变量的顺序
  1. 在子类方法的局部范围找,有就使用
  2. 在子类的成员范围找,有就使用
  3. 在父类成员范围找有就使用
  4. 如果找不到,就报错

super关键字

用法与this关键字类似

  • this 代表对本类对象的引用
  • super 代表父类存储空间的标识(可以理解为对父类对象的引用)

用法

  • 访问成员变量

    this.成员变量
    super.成员变量(访问父类的成员变量,不能访问父类的private变量)
    访问静态成员时,也可以用  父类名.静态成员
    
  • 访问构造方法

    this(...)  super(...)
    
  • 访问成员方法

    this.成员方法()  super.成员方法()
    
案列演示
    //创建父类
    public class FatherSuper {
        int num = 10;
        public FatherSuper(){
            System.out.println("父类构造方法");
        }
        public void show(){
            System.out.println("父类成员方法");
        }
    }
    public class SonSuper extends FatherSuper {
        int num = 15 ;
        public SonSuper(){
            System.out.println("子类构造方法");
        }
        public void method(){
            System.out.println("子类成员方法");
        }
        public void function(){
            int num = 5;                    
            System.out.println(num);        //打印方法内局部变量
            System.out.println(super.num);  //打印父类成员变量
            System.out.println(this.num);   //打印本类成员变量
            super.show();                   //调用父类成员方法
            this.method();                  //调用本类成员方法

        }
    }
    测试类
    public class SuperTest {
        public static void main(String[] args) {
            SonSuper ss = new SonSuper();
            ss.function();
        }
    }

继承中构造方法的关系

  1. 子类中所有的构造方法默认都会访问父类中空参数的构造方法,除非显示使用super/this调用了父类或者本类的其他构造方法。
  2. 在类中对本类或者父类构造方法的调用,只能在构造方法中,不能在实例方法总中调用构造方法(更不能在类方法中调用构造方法)
注意构造方法不能递归调用
    class A {
        public A(int i){
            this(1 ,2);
        }
        public A(int a ,int b){
            this(2);
        }
    }

案例演示

    //创建父类
    public class A {
        public A(){
            System.out.println("父类空参构造");
        }
        public A(String name){
            System.out.println("父类有参构造");
        }
    }
    //创建子类继承父类  
    public class B extends A {
        public B(){           //这一步默认执行了  super();调用了父类空参
            System.out.println("子类空参构造");
        }
        public B(String name){
            super(name);  //调用父类有参构造方法
            System.out.println("子类有参构造");
        }
    }
    测试类
    public class C {
        public static void main(String[] args) {
            B b = new B();
            B b1 = new B("tom");
        } 
    }   
如果父类没有空参构造,子类的构造方法中就必须显式调用父类带参构造super(...);
super(…)或者this(…)必须出现在构造方法第一条语句上否则,就会有父类数据的多次初始化

方法重写

子类中出现和父类中一摸一样的方法声明,称为方法覆盖(Override)或重写(OverWrite)

使用特点

  • 如果方法名不同就调用对应的方法
  • 如果方法名相同最终使用的是自己的(使用子类的引用的时候,在多态情况下,使用父类的引用,则有可能调用的是父类静态方法)

方法重写的应用

  • 当子类需要父类功能时,而功能主体子类有自己的特有的内容时,可以重写父类的方法,这样即沿袭了父类的功能,又定义了特有的内容。
  • 方法重写是多态实现的条件

    //首先创建 一个手机父类
    public class PhoneF {
        public void call(String name){   //定义一个方法
            System.out.println("给"+name+"打电话");
        }
    }
    //在创建一个手机子类继承父类
    public class PhoneS extends PhoneF {
        public void call(String name){   //同名同修饰词   对父类中的方法进行重写
            super.call(name);
            System.out.println("听天气预报");  //在继承父类之后在身再加的打印语句
        }
    }
    //创建测试类
    public class PhoneTest {
        public static void main(String[] args) {
            PhoneS ps = new PhoneS();
            ps.call("Tom");
        }
    }
    

方法重写的注意事项

  • 父类中私有的方法不能被重写,编译报错;
  • 子类重写父类方法时,访问权限不能更低,编译报错;
  • 子类重写父类方法时,返回值类型可以相同,也可以是父类返回值的子类型;
  • 父类的实例方法(非静态方法),子类不能重新定义为静态方法
  • 子类中的重写父类方法,按照重写的原则(访问权限不能变小,返回值类型同类或者为子类,方法名相同,形参列表相同);
  • 子类想重写父类的方法,最好是让方法的签名一模一样;

final关键字

final关键字是最终的意思,可以修饰类,成员变量,成员方法 - 修饰类,类不能被继承(不能放在extends后面) - 修饰变量,变量将变成常量只能被赋值一次,不论是在子类还是本类中,都不能被修改(常量一般是大写字母表示 final int ONE = 1) - 修饰方法,方法不能被重写(子类只用使用权,没有修改权)

final修饰局部变量
  • 在方法内部,该变量不可以被改变
  • 在方法声明上,基本类型是这个参数的值不能被改变,引用类型,是这个参数只想的地址值不能被改变

总结

类中非static的final变量(实例final变量)可以在生命的时候赋值,如果声明的时候没有赋值的话,就必须在以下两个地方赋值,一个是构造代码块一个是构造方法中,如果这两个地方没有赋值,编译报错。

如果是static修饰的final变量的话,则只能在两个地方赋值,声明的时候,或者在静态代码块中。

多态(polymorphism)

某一个事物,在不同时刻表现出来的不同状态

在Java中,对一个事物的引用可以分成两种类型,一种是编译时的类型,一种是运行时的类型。 编译时的类型指的是声明这个变量时指定的类型;运行时类型指的是实际赋给这个变量的对象的类型。

    若Student类继承自Person类,则下面的写法是正确的
    Person p = new Student();
注意

父类引用不能调用子类特有的方法,因为使用了父类的引用,就代表站在父类角度来看待当前子类对象,只能看到从父类继承而来的特性,或者是子类重写的父类的方法。成员变量没有多态性,只能看到父类的成员变量。

多态中的成员访问特点

  • 成员变量 编译看左边,运行看右边;
  • 构造方法 创建子类对象的时候,访问父类的构造方法,对父类的数据进行初始化
  • 成员方法 便宜看左边,运行看右边
  • 静态方法 编译看左边,运行看右边

多态的前提条件

  • 有继承关系
  • 有方法重写
  • 有父类引用指向子类对象

多态中成员访问特点

成员变量和静态方法没有多态性 只有被子类重写的成员方法才有多态性

以上是关于Day 08Java基础学习笔记的主要内容,如果未能解决你的问题,请参考以下文章

Python学习笔记-基础Day01

Java学习笔记day_01

day02 java基础学习笔记

Day12Java基础学习笔记

Day 09Java基础学习笔记

Day 11Java基础学习笔记