当前位置：首页 > article >正文

Java语法基础知识点2

article 2025/3/3 13:03:40

四、继承

4.1extends关键字：

4.2父类成员变量/方法访问：

4.3构造方法：

4.4protected关键字：

4.5final关键字：

4.6组合

五、多态

5.1发生多态的前提：

5.2向上转型和向下转型：

5.3方法重写：

四、继承

4.1extends关键字：

如果想要继承，那么就要使用到extends关键字，继承是对共性的抽取，实现代码的复用

基础语法如下：class 子类 extends 父类{}

//把猫和狗所有相同的成员变量进行抽取，放到Animals父类中，只要发生继承关系，就能够使用name和age成员变量
class Animals{
    public String name;  
    public int age;
}

//狗有名字和年龄
class Dog extends Animals{
}

//猫也有名字和年龄
class Cat extends Animals{
}

public class Main {
    public static void main(String[] args) {
        Dog dog=new Dog();
        Cat cat=new Cat();
    }
}

4.2父类成员变量/方法访问：

super关键字：这是子类访问父类成员变量/方法的关键字，作用类似于this关键字，但是super只能够用在发生继承关系访问父类的成员变量/方法上，具体用法如下：

class Animals{
    public String name;
    public int age;

    public void Sleep(){
        System.out.println(this.name+"正在睡觉");
    }
}

class Dog extends Animals{
    public void Bark(){
        super.Sleep(); 
        System.out.println(super.name+"汪汪叫");

    }
}

class Cat extends Animals{
    public void miaomiao(){
        System.out.println(super.name+"喵喵叫");
    }
}

特别注意的是，如果子类和父类出现同名情况下，不使用super关键字的话，会优先访问子类同名的成员变量/方法；如果没有同名的话，就会访问父类的成员变量/方法，如果访问的变量在子类和父类都没有，那么就会报错

4.3构造方法：

父类的构造方法跟子类的构造方法类似，如果没有显示定义，那么编译器会自动生成一个无参的构造方法

class Animals{
    public String name;
    public int age;

    public Animals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void Sleep(){
        System.out.println(this.name+"正在睡觉");
    }
}

class Dog extends Animals{
    
    //由于父类显示定义构造方法，那么我们在子类构造方法中就要用到super关键字给name和age传值
    public Dog(String name, int age) {
        super(name, age);
    }

    //如果父类没有定义构造方法，那么编译器会自动生成一个无参构造方法，那么子类构造方法中的super()里就没有值public Dog(){    super();}
}

4.4protected关键字：

是个包子权限，在不同包的情况下，只有子类能够访问被protected修饰的父类的成员变量/方法

4.5继承方式：

支持单继承，多层继承，但是不支持多继承，就是一个子类继承多个父类；

4.5final关键字：

被final修饰的变量，就会变成常量，不能被修改：

        final int a=10;
        a=9;//报错，因为a被final修饰，此时的a就是常量10

如果final修饰的是类，那么就说明这个类不能够被继承

如果final修饰方法，那么这个方法就不能被重写

4.6组合

组合与继承相似，但是不同的点就是组合是对象之间是has-a的关系，例如汽车，汽车有零配件轮胎、方向盘等，创建一个Car类时，同时创建零配件轮胎、方向盘对象，如果销毁Car类，那么零配件也会一同销毁

//轮胎
class LunTai{

}
//方向盘
class FangXiangPan{

}
//汽车
class Car{
    private LunTai lt;
    private FangXiangPan fxp;

}
//宝马是汽车，可以继承汽车当中的轮胎，方向盘
class BaoMa extends Car{
    
}

五、多态

5.1发生多态的前提：

多态的意思就是，如果不同的对象去执行同一件事，会产生不同的结果；发生向上转型、对父类方法进行重写，并且要在继承体系下这三个是发生多态的前提。

5.2向上转型和向下转型：

向上转型是创建一个子类对象给到父类对象使用，这是一个小范围到大范围的转换，例如狗是动物

语法格式如下：父类类型变量名=new 子类类型()

class Animals{
    public String name;
    public int age;

    public Animals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(this.name+"正在吃");
    }
}
class Dog extends Animals{      //继承
    public Dog(String name,int age){
        super(name,age);
    }

    @Override
    public void eat() {           //对父类方法进行重写
        System.out.println(super.name+"吃狗粮");
    }
}
public class Main {
    public static void main(String[] args) {
        Animals dog=new Dog("小黑",7);  //发生向上转型
        dog.eat();//输出结果是小黑吃狗粮，而不是小黑正在吃
    }
}

向上转型使用的场景有三个：直接赋值、方法传参、方法返回

向下转型：

我们知道，如果发生向上转型的话，只能够访问到父类的方法和变量，却不能够访问到子类的方法和变量，如果我们要访问到子类的方法和变量，那么我们就要用到向下转型，以下是向下转型的例子：

class Animals{
    public void eat(){
        System.out.println("正在吃");
    }
}
class Dog extends Animals{

    @Override
    public void eat() {
        System.out.println("吃狗粮");
    }
    public void Sleep(){
        System.out.println("在睡觉");
    }
}

public class Main {
    public static void main(String[] args) {
        Animals a1=new Dog();//发生向上转型
        if (a1 instanceof Dog){   //这里的instanceof意思是如果a1引用的是Dog对象，那么true
            Dog dog=(Dog)a1;//如果要访问到子类的Sleep方法，就要发生向下转型，一定要强制类型转换，因为不是所有的动物都是狗这里是大范围向小范围转换了
            dog.Sleep();  //此时就能够访问到子类的方法了
        }
    }
}