面向对象高级一static， 继承，极限修饰符，Object类，方法重写，super,子类构造器

目录

1.static 

代码块

2.继承

继承的注意事项：

(1)极限修饰符

(2)单继承，Object类

3.方法重写

4.super

5.子类构造器：

---

1.static （s但第可）

静态，可以修饰成员变量成员方法

1.成员变量按照有无static修饰，分为两种：

（1）类变量:

       public  class  Student{

   //类变量

       public  static String name;        //有static修饰，属于类，在计算机只有一份，会被类的全部对象共享

       Test类：Student.name = "";    //类名.类变量（）

注意：访问自己类中的类变量，可以省略类名不写

  (2)  //实例变量(对象的变量）

       int  age;      //属于每个对象的

2.（1）类方法  ：有static修饰的成员方法，属于类

public static void printHelloWorld(){}       

 Student.printHelloWorld();      //类名.类方法

（2）实例方法：无static修饰的成员方法，属于对象            

 public  void printLeLe(){} 

Student s1 = new Student();

s1.printLeLe();            //对象.实例方法

注意：1、类方法中可以直接访问类的成员，不可以直接访问实例成员。

2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。

3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的

类方法可以用来设计工具类。工具类中的方法都是类方法，每个类方法都是用来完成一个功能的。

要求：工具类不需要创建对象，建议将工具类的构造器进行私有。

案例：四位随机验证码

public class LoginDemo {
  private LoginDemo{
}
    public static String util(int n) {

        //1.定义两个变量 一个是记住最终的随机验证码，一个是记住可能用到的全部字符
        String data = "abcdefghijklmnopqistuvwsyxzABCDEFGHIJKLMNOPQISTUVWSYZ123456789";
        String code ="";
        Random s =new Random();
        //开始定义一个循环产生的每位随机字符
        for (int i = 0; i <n ; i++) {
            int index = s.nextInt(data.length());
            code += data.charAt(index);
        }
       return code;
        }
    }


//
public class my_util {
    public static void main(String[] args) {
        System.out.println(LoginDemo.util(8));
    }
}

代码块

静态代码块：static{ }     自动执行，类加载一次，执行一次。，完成类初始化

实例代码块  {} 和构造器一样，完成对象的初始化

//Student类
public class Student {
    static int number = 80;
    static String schoolName = "黑马";
    // 静态代码块
    static {
        System.out.println("静态代码块执行了~~");
        // schoolName = "黑马";
    }
    int age;
    // 实例代码块
    {
        System.out.println("实例代码块执行了~~");
        // age = 18;
        System.out.println("有人创建了对象：" + this);
    }

    public Student(){
        System.out.println("无参数构造器执行了~~");
    }

    public Student(String name){
        System.out.println("有参数构造器执行了~~");
    }

//
public class Test {
    public static void main(String[] args) {
        // 目标：认识两种代码块，了解他们的特点和基本作用。
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);

        System.out.println(Student.schoolName); // 黑马

        System.out.println("---------------------------------------");
        Student s1 = new Student();
        Student s2 = new Student("张三");
        System.out.println(s1.age);
        System.out.println(s2.age);
    }

2.继承

extends,建立父子关系

特点：子类能继承父类的非私有成员(成员变量、成员方法)。
子类的对象是由子类、父类共同完成的。

public class A {
    public int i;
    public  void print1(){
        System.out.println("====print1");
    }
    //私有成员
    private  int j;
    private  void print2(){
        System.out.println("=====print2===============");
    }
}

public class B extends A{
    public void print3(){
        System.out.println(i);
        print1();
    }

继承的好处：减少重复代码编写

//People类
public class People {
    private String name;

    public String getName() {
        return name;
    }

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

//Teacher类
public class Teacher extends People{
    private String skill;

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    public void printInfo(){
        System.out.println(getName() + "具备的技能：" + skill);
    }
}

//类
public class Test {
    public static void main(String[] args) {
        // 目标：搞清楚继承的好处。
        Teacher t = new Teacher();
        t.setName("乐乐");
        t.setSkill("Java、Spring");
        System.out.println(t.getName());
        System.out.println(t.getSkill());
        t.printInfo();
    }
}

继承的注意事项：

(1)极限修饰符

private（破软为特）<缺省<protected（破软丹迪克）<public（怕不理克）

(2)单继承，Object类

Java是单继承的:一个类只能继承一个直接父类;Java中的类不支持多继承，但是支持多层继承。
Object类是Java中所有类的祖宗。

3.方法重写

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称 参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意:重写后，方法的访问，lava会遵循就近原则。

方法重写的其它注意事项：
重写小技巧:使用Override注解，他可以指定java编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。
子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限( public>protected>缺省).
重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
私有方法、静态方法不能被重写，如果重写会报错的.

应用场景：子类重写Object类的toString（）方法，以便返回对象的内容。

 @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

在子类方法中访问其他成员(成员变量、成员方法)，是依照就近原则的。

4.super

指定访问父类的成员变量，方法 

5.子类构造器：

（1）特点：子类的全部构造器，都会先调用父类的构造器（主要看无参构造器），在执行自己   //super(); 默认存在

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

class Teacher extends People
private string skill;
public Teacher(String name, int age, String skill)；
super(name ，age);
this.skill = skill;
}

补充知识:this(..)调用兄弟构造器
任意类的构造器中，都可以通过this()去调用该类的其他构造器。

this:局部变量与成员变量冲突，前加this,//子类成员变量