Day01了解Static与extends

Static关键字

被Static修饰的成员变量称为静态变量(类变量),类变量生命周期和类相同,在整个应用程序执行期间都有效,还可以修饰成员方法.

 注意:

      1.类方法中可以直接访问类成员,不可以直接访问实例成员

      2.实例方法中及可以直接访问类成员,也可以直接访问实例成员

      3.实例方法中可以出现this关键字,类方法中不可以出现this 

Static方法 

静态方法不依赖于任何对象就可以访问,因此内部不能调用非静态成员和方法,常被用做编写工具类.提高代码复用性,通过类名.方法名的方式节省内存空间.

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(MathUtil.max(10, 20));
    }
}

class MathUtil{

    //构造器私有,不允许创建对象
    private MathUtil(){};

    //求最大值
    public static int max(int a, int b){
        return a > b ? a:b;
    }

    //求最小值
    public static int min(int a, int b){
        return a < b ? a:b;
    }

    //求两个数的总和
    public static int sum(int a, int b){
        return a+b;
    }
}

Static成员变量 

属于类,与类一起加载,存在方法区,在内存中内有一份,被类的所以对象共享

public class User {

    static int num;
    public static void main(String[] args) {
         new User();
         new User();
        new User();
        System.out.println(num);

    }
    public User(){
        num++;
    }
}

3

访问自己类中的类变量，是否可以省略类名不写？

可以的
注意：在某个类中访问其他类里的类变量，必须带类名访问

 静态代码块

public class Day01main {
    public static void main(String[] args) {

        //类加载
        System.out.println(Students.name);
        System.out.println(Students.name);

        //对象创建
        Students s = new Students();
        Students s1 = new Students();
    }
}

class Students{

    public static String name;

    public int age;

    static {
    //给类中的静态变量赋值
        name = "卷王";
        System.out.println("卷王执行了");
    }

    //实例代码块:每次创建对象执行,并在构造器前执行
    {
        System.out.println("对象创建");
    }

    public Students(){
        System.out.println("students的构造器");
    }
}




卷王执行了
卷王
卷王
对象创建
students的构造器
对象创建
students的构造器

Process finished with exit code 0

继承Extends 

 1.子类能继承并使用父类的非私有成员(成员变量、成员方法) 

 2.子类的创建由父类和子类共同完成

 3. 减少了重复代码的编写，提高了代码的复用性

 4.Java是单继承的，Java中的类不支持多继承，但是支持多层继承

方法重写 

1.当子类觉得父类方法不好用，或者无法满足父类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法 

2.重写的方法上建议添加注解@Override

3.私有方法和类方法不能重写

4.重写方法的访问权限>=父类中的方法访问权限

5.重写方法的返回值类型范围<=父类中方法的返回值类型范围

子类中访问其他成员的特点 

1.在子类中访问其他成员（成员变量、成员方法），是依据就近原则的

2.若在子类中需要访问父类同名成员的话,添加super区分 

子类构造器的特点 

1.子类中的全部构造器，都必须先调用父类的构造器，再执行自己

2.super()用来访问父类的构造器

3.this()用来访问本类中的构造器

4.this和super访问构造方法，只能用到构造方法的第一句，否则会报错, 他俩不能同时出现。

子类构造器如何调用父类构造器 

1.默认情况下,子类全部构造器的第一行代码都是 super() (写不写都有),它会调用父类的无参数构造器.

2.如果父类没有无参数构造器,则我们必须在子类构造器的第一行手写super(….),指定去调用父类的有参数构造器。

子类构造器调用父类构造器的应用场景 

我们经常在子类构造器中调用父类的有参构造器给父类传递参数来完成父类对象的初始化 

public class Demo03 {
    public static void main(String[] args) {

        Studentd studentd = new Studentd("卷王","23","ii");
        System.out.println(studentd.getSki());
        System.out.println(studentd.getAge());
        System.out.println(studentd.getName());
    }
}

class Peoper{

    private String name;
    private String age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

class Studentd extends Peoper{

    private String ski;

    public Studentd(String name, String age, String ski) {
        super(name, age);
        this.ski = ski;

    }

    public String getSki() {
        return ski;
    }

    public void setSki(String ski) {
        this.ski = ski;
    }
}