Java学习笔记-基础语法Ⅲ

继承：子类使用extends来继承父类，子类可以有父类的内容，还可以有子类自己特有的内容

继承的好处：

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

• 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

继承的弊端：

• 继承让类的耦合性增强了，父类发生变化时，子类页发生变化，削弱子类的独立性

继承中变量访问特点：

• 子类局部范围找
• 子类成员范围找
• 父类成员范围找
• 都没有就报错

// 父类
public class Fu {
    public int age = 30;
}

// 子类
public class Zi extends Fu{
    public String name = "kkk";
    public int age = 40;
    public void show(){
        // age = 50;
        System.out.println(name+age);
    }
}

// 测试类
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

super关键字的用法和this关键字的用法相似：

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

父类构造方法不会被继承，构造方法是用来初始化对象的

构造方法前面是不能加void之类的返回值，加了就不是构造方法，系统会识别成普通方法

子类所有构造方法都会默认访问父类中无参的构造方法

子类会继承父类中的数据，还可能使用父类的数据，所有子类初始化之前会完成父类的初始化，每个子类构造方法的第一条语句默认都是super()

// 父类
public class Fu {
    // 注意，这里的无参构造方法如果不写，那么子类不能直接super()，或者无法直接继承父类的无参构造方法
    public Fu(){
        System.out.println("父中无参构造方法被调用");
    }
    public Fu(int age){
        System.out.println("父中带参构造方法被调用");
    }
}

// 子类
public class Zi extends Fu{
    public Zi(){
        // super();
        // 要么调用父类无参构造方法，要么调用父类带参构造方法
        // 只能调用其中一个，多了会报错
        super(30);
        System.out.println("子中无参构造方法被调用");
    }
    public Zi(int age){
        System.out.println("子中带参构造方法被调用");
    }
}

// 测试类
public class Super_Demo {
    public static void main(String[] args) {
        Zi z1 = new Zi();
        Zi z2 = new Zi(30);
    }
}

// 结果
父中带参构造方法被调用
子中无参构造方法被调用
父中无参构造方法被调用
子中带参构造方法被调用

方法重写：子类中出现了和父类中一模一样的方法声明

@Override可以帮助检查方法重写

Java有四种访问权限

	同一个类	同一个包	不同包的子类	不同包的非子类
Private	√
	√	√
Protected	√	√	√
Public	√	√	√	√

方法重写的时候要注意，私有方法不能被重写，且子类方法访问权限不能更低，public>protected>默认>private

Java支持多层继承，但不支持多继承

包，其实就是文件夹，作用是对类进行分类管理，格式为

• package 包名;
• package 一级包.二级包;

要弄清楚四种访问权限的话，需要耐心把代码敲一遍

// 注意这里的包，demo1下有Fu、Zi、Demo三个Java文件
package demo1;

public class Fu {
    private void show1(){
        System.out.println("private 方法可以被调用");
    }
    void show2(){
        System.out.println("默认的方法可以被调用");
    }
    protected void show3(){
        System.out.println("protected 方法可以被调用");
    }
    public void show4(){
        System.out.println("public 方法可以被调用");
    }

    public static void main(String[] args) {

        Fu d1 = new Fu();
        d1.show1();
        d1.show2();
        d1.show3();
        d1.show4();
    }
}
// 这里的意思是同一个类下，四种访问权限的方法都可以访问

// 还是demo1的包，Zi继承Fu，现在不能调用private修饰的方法了
package demo1;

public class Zi extends Fu{
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

package demo1;

public class Demo {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show4();
        f.show3();
        f.show2();
    }
}
// 这里表示，只要是同一个包下，继承不继承，都是可以调用除private权限外的3种访问权限

现在到别的包下，看看访问权限

package demo2;

import demo1.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show3();
        z.show4();

        Fu f = new Fu();
        f.show4();
    }
}
// 其他包下，继承关系，只能调用public和protected
// 没有关系的对象，只能调用public

package demo2;

import demo1.Fu;

public class Demo {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show4();
    }
}

这上面是黑马视频讲的内容，但是可能读者还有疑问，如果是不同包下，进行多层继承呢？也就是如果demo2下的包继承demo1中的Zi，又是什么情况呢？

package demo2;

import demo1.Zi;

public class zz extends Zi {
    public static void main(String[] args) {
        zz zz2 = new zz();
        zz2.show3();
        zz2.show4();
    }
}
// 结果还是只有protected和public两种权限

修饰符final

final可以修饰成员方法，成员变量，类

final修饰的特点，对方法则不能被重写，对变量则不能被再次赋值，对类则不能被继承

对于变量，final修饰基本类型时数据值不能改变，修饰引用类型的地址值不能改变，但是地址里面的值可以改变

// java类
public class Student {
    public int age;
    public String name;
    public void show(){
        System.out.println(age+name);
    }
}

// 测试类
public class Demo {
    public static void main(String[] args) {
        final int age = 20;
        // final修饰基本数据类型，其值不能改变
//        age = 30;
        System.out.println(age);
        final Student s = new Student();
        s.age = 40;
        s.show();
        s.age = 50;
        s.show();
    }
}

static修饰符修饰成员方法、成员变量

static修饰的对象共享

// 学生类
public class Student {
    public int age;
    public String name;
    public static String school;
    public void show(){
        System.out.println(name+", "+age+", "+school);
    }
}

// 测试类
public class Demo {
    public static void main(String[] args) {
        Student s1 = new Student();
        // Student.school = "浙江大学";
        s1.age = 18;
        s1.name = "林青霞";
        s1.school = "浙江大学";
        s1.show();

        Student s2 = new Student();
        s2.age = 28;
        s2.name = "张曼玉";
        s2.show();
        s2.school = "华科";
        s2.show();
        s1.show();
    }
}

林青霞, 18, 浙江大学
张曼玉, 28, 浙江大学
张曼玉, 28, 华科
林青霞, 18, 华科

static修饰的变量，推荐使用类名调用，也可以使用对象名调用

静态的只能调用静态的，非静态的都可以进行调用

public class Demo {
    public String name;
    public static String age;

    // 非静态
    public void show1(){}
    // 静态
    public static void show2(){}

    // 非静态的都能调用
    public void show3(){
        System.out.println(name);
        System.out.println(age);
        show1();
        show2();
    }
    
    // 静态的只能调用静态的
    public static void show4(){
        System.out.println(name);
        System.out.println(age);
        show1();
        show2();
    }

    public static void main(String[] args) {
        Demo de = new Demo();
        de.show3();
        de.show4();
    }
}