static&继承&多态&包&final&权限修饰符&代码块

月亮不睡你不睡，你是秃头小宝贝

已于 2023-04-01 15:55:30 修改

阅读量56

点赞数

文章标签： java

于 2023-04-01 15:00:26 首次发布

本文链接：https://blog.csdn.net/weixin_52009660/article/details/129897349

版权

1.Static静态变量

static表示静态变量，是Java中的一个修饰符，可以修饰成员方法，成员变量

（静态变量随着类的加载而加载，优先于对象出现。静态区中的变量共享，谁用，谁去调用）

被static修饰的成员变量，叫做静态变量	被static修饰的成员方法，叫静态方法
特点：被该类的所有对象共享；不属于对象属于类；随着类的加载而加载优于对象存在调用方式：类名调用（推荐）对象名调用	特点：对用在测试类和工具类中，Javabean中很少使用调用方式：类名调用；对象名调用

静态方法只能访问静态变量和方法
非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中没有this关键字

总结：静态方法中，只能访问静态；非静态方法可以访问所有；静态方法中没有this关键字

public class Helloword{
    public static void main(String[] args){
       //public:  被JVM调用，访问权限足够大
       //static： 被JVM调用，不用创建对象，直接类名访问，因为main方法是静态的，所以测试类中其他方法也需要静态的
       //void：被JVM调用，不需要给JVM返回值
       //main： 一个通用的名称，虽然不是关键字，但是被JVM识别
       //String[] args：以前用于接受键盘录入数据的，现在已经没用了。（界面运行按钮的左边，点击选择Edit Configuration在program arguments输入传递参数）
    }
}

2.工具类

定义时：类名见名知意；私有结构化构造方法；方法定义为静态

Javabean类：用来描述一类事物的类。比如Student、Teacher、Dog等

测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口

工具类：不是用来描述一类事物的，而是帮我们做一些事情的类

3.继承

3.1关键字extends

public class 子类 extends 父类{}

使用继承的好处：

可以把多个子类（派生类）中重复的代码抽取到父类（基类或者超类）中，提高代码的复用性，减少代码冗余，提高代码的复用性
子类可以在父类的基础上，增加其他的功能，是子类更加强大。

3.2什么时候用继承

当类与类之间，存在相同的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

3.3继承的特点

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

单继承：一个子类只能继承一个直接父类

多继承：子类不能同时继承多个父类

多层继承：子类A继承父类B，B继承父类C。C则是A的间接父类

每个类都直接或者间接的继承于Object

子类只能访问父类的非私有的成员

3.4子类能在父类中继承那些内容

构造方法：非私有（不能） private（不能)

成员变量：非私有（能） private（能）

成员方法：非私有，在虚方法表中（能） private（不能）

3.4.1继承中成员变量访问特点：就近原则

先在局部位置找，本类位置找，父类成员位置找，逐级往上。

class Fu{
    String name = "Fu";
}
class Zi extends Fu{
    String name = "Zi";
    public void zishow(){
        String name = "zishow";
        System.out.println(name);//就近原则调用zishow方法中的name变量
        System.out.println(this.name);//调用的是Zi类中name变量
        System.out.println(super.name);//调用的是Fu类中name的变量
    }
}

3.4.2继承中成员方法访问特点

class Person{
    public void eat(){
        System.out.println("吃米饭，吃菜");
    }
    public void drink(){
        System.out.println("喝开水");
    }
}

class Student extends Person{
    //先在本类中查看eat和drink方法，就会调用子类的，如果没有，就会调用从父类中继承下来的eat和drink方法
    public void lunch(){
        eat();//隐含了this
        drink();
        
        //直接在父类中寻找调用
        super.eat();
        super.drink();
    }
}

3.4.3继承中构造方法的访问特点

父类中的构造方法不会被子类继承
子类中所有的构造方法默认先访问父类中的无参构造，在执行自己

为什么？
- 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类中的数据
- 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化
怎么调用？
- 子类中构造方法第一行语句默认都是：super（），不写也存在且必须在第一行。
  - 如果想调用父类有参构造，必须手动写super进行调用。

3.5方法的重写

当父类中的方法不能满足子类现在的需求时，需要进行方法重写

**书写格式：**在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

@Override重写注解：1. @Override是放在重写后的方法上，校验子类重写时语法是否正确。

2.加上注解后如果有红色波浪线，表示语法错误。

3.建议重写方法都加上@Override注解，代码安全

方法重写本质：覆盖虚方法表中继承的父类方法

方法重写注意事项和要求：

重写方法的名称、形参列表必须与父类中的一致
子类重写父类方法时，访问权限子类必须大于等于父类(空着不写<protected<public)
子类重写父类方法时，返回值类型子类必须小于等于父类
建议：重写方法尽量和父类保持一致
只有被添加到虚方法表中的方法才能被重

4.多态

4.1多态基本理解

**①什么是多态？**同类型的对象，表现出的不同形态。

②多态的表现形式： 父类类型对象名称 = 子类对象

③多态的前提：

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

**④多态的好处？**使用父类作为参数，可以接收所有子类对象，体现多态的扩展性与便利

4.2多态调用成员的特点

变量调用：编译看左边，运行看左边。（编译javac代码时，看左边父类中有没有这个变量，如果有则编译成功否则编译失败)（运行java代码时实际获取的就是左边父类中的变量）
方法调用：编译看左边，运行看右边。（编译javac代码时，看左边父类中有没有这个变量，如果有则编译成功否则编译失败)（运行Java代码时实际获取子类的方法）

4.3多态的优势及劣势

优势：

在多态的形势下，右边对象可以实现解耦合，便于维护和扩展。

Person p = new Student();
p.work();//业务逻辑发生改变时，后续代码无需更改

定义方法时，使用父类类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。

劣势：

不能直接使用子类的特有功能，需要转换类型（注意转换类型时，要转换为对应的类型，Dog转换为Dog）

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.eat();
        //多态的弊端
        //不能调用子类的特有功能
        //a.lookHome()
        
        //报错原因？编译看父类中有没有方法，没有则报错
        //解决方法：变回子类类型
        //注意转换的时候，不能转换成其他类型，狗类型不能转换为猫类型
        //Dog dog  = (Dog) a;
        //dog.lookHome();

        //Java判断特性  instanceof
        /*if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.lookHome();
        } else if (a instanceof  Cat) {
            Cat c =(Cat) a;
            c.catchHome();
        }else{
            System.out.println("没有这个类型");
        }*/
        //JDK14新特性
        //先判断a是否为Dog类型，如果是则强转Dog类型，转换之后变量名为dog,如果不是则不强转
        if(a instanceof Dog dog){
            dog.lookHome();
        } else if (a instanceof  Cat c) {
            c.catchMouse();
        }else{
            System.out.println("没有这个类型");
        }
    }
}
class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void lookHome() {
        System.out.println("狗看家");
    }
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼干");
    }
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}