Java入门篇之多态

news2024/11/23 3:14:40

本篇碎碎念：个人认为，一切都不是不学习的理由，在如今这个"内卷"的时代，唯有认真学习，掌握知识，才能把握命运

今日份励志文案:你必须拼尽全力，才有资格说运气不好

加油吧，少年，胜利的曙光就在前方！！！

补充上条博客的知识点：

代码块的运行顺序

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行（也就是说静态代码块只执行一次）

代码举例如下:


class A{
    public String name;
    public int age;
    public A(String name,int age){
        this.age=age;
        this.name=name;
        System.out.println("父类中的构造方法");

    }
    static{
        System.out.println("父类中的静态代码");
    }
    {
        System.out.println("父类中的实例代码块");
    }
}
class B extends A{
    public String color;
    public B(String name,int age,String color){
        super(name,age);
        this.color=color;
        System.out.println("子类中的构造方法");
        System.out.println("name :"+name+",age:"+age+",color:"+color);
    }
    static{
        System.out.println("子类中的静态代码");
    }
    {
        System.out.println("子类中的实例代码块");
    }
}



//main函数下的代码

    public static void main(String[] args){
        B b=new B("小红",3,"红色");
    }

public static void main(String[] args){
        B b=new B("小红",3,"红色");
        B b1=new B("小绿",4,"绿色");
    }

补上章缺失的知识点

多态

在面向对象的程序设计语言中，多态是继数据抽象和继承之后的第三种基本特征

多态不但能改善代码的组织结构和可读性，还能够创建可扩展的程序----即无论在项目最初创建时函数在需要添加新功能时都可以"生长"的程序

多态的作用是消除类型之间的耦合关系；只要他们都是从同一基类导出而来的，多态方法调用允许一种类型表现出与其他相似类型之间的区别，这种区别是根据方法行为的不同而表示出来的，虽然这些方法都可以通过一个基类来调用

总的来说，多态就是一个对象在不同条件下的表现出的不同形式1.1向上转型

把子类对象叠给父类(父类是引用，引用了子类对象)，从小范围向大范围的转换

博主个人理解:就是创建了一个子类对象，将其当成父亲对象来使用

父类类型变量名 = new 子类类型()；

例如父类是Animal，子类是Dog，

Animal animal=new Dog ()（本质还是Animal，只能调用Animal特有的）

向上转型的三种方式:

这个解释中创建了两个子类，一个是Dog,一个是Bird

在下面理解多态时，是说两个子类中都有eat，两个eat的输出不一样，从而引出了多态的概念

同一个引用调用了同一个方法，但是因为引用的对象不一样，所表现的行为不一样

1.2.1直接赋值

class Animal2{

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

    public void print1(){
        System.out.println("父类中的狗狗名字叫:"+this.name+
                ",狗狗"+this.age+"岁");
    }
}
class Dog extends Animal2{

    public String color;
    public Dog(String name,int age,String color){
        super(name,age);
        this.color=color;
    }

    public void print(){
        System.out.println("狗狗名字叫:"+this.name+
                           ",狗狗"+this.age+"岁"+
                           ",狗狗是"+this.color);
    }
   
}


//main函数中的

public static void main(String[] args) {

        Dog dog = new Dog("小黑", 3, "黑色");
        dog.print();
        Animal2 animal = dog;
        animal.prubt1();
    }

1.2.2通过传参


  public static void fun(Animal2 animal){
        animal.print1();
    }
    public static void main(String[] args) {
        Dog dog=new Dog("小花",2,"花色");
        fun(dog);

    }

1.2.3通过返回值，进行向上转型

    public static Animal2 fun2(){
        return new Dog("小蓝",5,"蓝色");
    }
    public static void main(String[] args) {
        Animal2 animal2=fun2();
        animal2.print1();
    }

向上转型的优点:让代码实现更简单灵活

向上转型的缺陷:不能调用到子类特有的方法

重写:

方法重写的规则:

1.子类在重写父类的方法时，一般必须与父类方法原型一致:返回值类型方法名(参数列表)要完全一

2.被重写的方法返回值类型可以不同，但是必须是具有父子关系的

3.访问权限不能比父类中被重写的方法的访问权限更低；例如:如果父类方法被public修饰，则子类中重写该方法就不能声明为protected

4.父类被static、private修饰的方法、构造方法都不能被重写

5.重写的方法,可以使用@Override注解来显式指定.有了这个注解能帮我们进行一些合法性校验.例如不小心将方法名字拼写错了(比如写成aet),那么此时编译器就会发现父类中没有aet方法,就会编译报错,提示无法构成重写.

注意：不可以重写父类中的对象

finnal关键字:

3.Final还可以修饰方法(代表该方法不能重写)

//在子类中添加的
 @Override
    public void print1() {
        System.out.println("重写后父类中的狗狗名字叫:"+this.name+
                            "狗狗"+this.age);
    }



//main函数中

  public static void main(String[] args) {
        Animal2 dog = new Dog("小黑", 3, "黑色");
        dog.print1();
    }