Java 面向高级（一）

落日映苍穹つ 2024-03-03 03:34 36阅读 0赞

### 一、静态 ###

接下来，我们学习一下面向对象编程中很常见的一个关键字static。

static读作静态，可以用来修饰成员变量，也能修饰成员方法。我们先来学习static修饰成员变量。

#### 1、static修饰成员变量 ####

Java中的成员变量按照有无static修饰分为两种：**类变量、实例变量**。它们的区别如下图所示：

![522b2c8692a348d999b489dc221460fc.png][]

由于静态变量是属于类的，只需要通过类名就可以调用： 类名.静态变量。

实例变量是属于对象的，需要通过对象才能调用：对象.实例变量。

*  下面是代码演示（注意静态变量，和实例变量是如何调用的）

![50ebbad32da24a20936264e460df471f.png][]

为了让大家对于这两种成员变量的执行过程理解更清楚一点，我们来看一下上面代码的内存原理。

![4f71dd72bca24ef38bf517478bea315f.png][]

> 总结：
> 
> 1.  类变量：属于类，在内存中只有一份，用类名调用
> 2.  实例变量：属于对象，每一个对象都有一份，用对象调用

##### 1.1 static修饰成员变量的应用场景 #####

在实际开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住。

我们看以一个案例：

> 需求：系统启动后，要求用于类可以记住自己创建了多少个用户对象。

*  第一步：先定义一个**User**类，在用户类中定义一个static修饰的变量，用来表示在线人数；

public class User{
        public static int number;
        //每次创建对象时，number自增一下
        public User(){
            User.number++;
        }
    }

*  第二步：再写一个测试类，再测试类中创建4个User对象，再打印number的值，观察number的值是否再自增。

public class Test{
        public static void main(String[] args){
            //创建4个对象
            new User();
            new User();
            new User();
            new User(); 
            
            //查看系统创建了多少个User对象
            System.out.println("系统创建的User对象个数："+User.number);
        }
    }

运行上面的代码，查看执行结果是：系统创建的user对象个数：4

#### 2、static修饰成员方法 ####

成员方法根据有无static也分为两类：**类方法、实例方法** 。

![2a006926204b40f281dc9d6c1467771d.png][]

> 有static修饰的方法，是属于类的，称为**类方法**；调用时直接用类名调用即可。
> 
> 无static修饰的方法，是属于对象的，称为实例方法；调用时，需要使用对象调用。

下面通过案例，演示类方法、实力方法的基本使用：

*  先定义一个Student类，在类中定义一个类方法、定义一个实例方法

public class Student{
        double score;
        
        //类方法：
        public static void printHelloWorld{
            System.out.println("Hello World!");
            System.out.println("Hello World!");
        }
        
        //实例方法（对象的方法）
        public void printPass(){
            //打印成绩是否合格
            System.out.println(score>=60?"成绩合格":"成绩不合格");
        }
    }

*  在定义一个测试类，注意类方法、对象方法调用的区别

public class Test2{
        public static void main(String[] args){
            //1.调用Student类中的类方法
            Student.printHelloWorld();
            
            //2.调用Student类中的实例方法
            Student s = new Student();        
            s.printPass();
            
            //使用对象也能调用类方法【不推荐，IDEA连提示都不给你，你就别这么用了】
            s.printHelloWorld();
        }
    }

搞清楚类方法和实例方法如何调用之后，接下来聊一聊static修饰成员方法的内存原理。

![fb80705cacf44d63b4b030b3cefd5307.png][]

> 1. 类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的；所以类名直接就可以找到static修饰的方法。
> 
> 2. 实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实例变量，而实例变量需要创建对象后才存在。所以实例方法，必须创建对象后才能调用。

#### 3、工具类 ####

如果一个类中的方法全都是静态的，那么这个类中的方法就全都可以被类名直接调用，由于调用起来非常方便，就像一个工具一下，所以把这样的类就叫做工具类。

*  我们写一个生成验证码的工具类

public class MyUtils{
        public static String createCode(int n){
            //1.定义一个字符串，用来记录产生的验证码
            String code = "";
            
            //2.验证码是由所有的大写字母、小写字母或者数字字符组成
            //这里先把所有的字符写成一个字符串，一会从字符串中随机找字符
            String data = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKMNOPQRSTUVWXYZ";
            
            //3.循环n次，产生n个索引,再通过索引获取字符
            Random r = new Random();
            for(int i=0; i<n; i++){
                int index = r.nextInt(data.length());
                char ch = data.charAt(index);
                //4.把获取到的字符，拼接到code验证码字符串上。
                code+=ch;
            }
            
            //最后返回code,code的值就是验证码
            return code;
        }
    }

*  接着可以在任何位置调用MyUtils的createCode()方法产生任意个数的验证码。

//比如这是一个登录界面
    public class LoginDemo{
        public static void main(String[] args){
            System.out.println(MyUtils.createCode());
        }
    }

//比如这是一个注册界面
    public class registerDemo{
        public static void main(String[] args){
            System.out.println(MyUtils.createCode());
        }
    }

#### 4、static的注意事项 ####

![cae891164c614dd69ae93f12775541bb.png][]

public class Student {
        static String schoolName; // 类变量
        double score; // 实例变量
    
        // 1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
        public static void printHelloWorld(){
            // 注意：同一个类中，访问类成员，可以省略类名不写。
            schoolName = "黑马";
            printHelloWorld2();
    
            System.out.println(score); // 报错的
            printPass(); // 报错的
    
            ystem.out.println(this); // 报错的
        }
        
    	// 类方法
        public static void printHelloWorld2(){
    
        }
        
        // 实例方法
        public void printPass2(){
    
        }
        
        // 实例方法
        // 2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
        // 3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的
        public void printPass(){
            schoolName = "黑马2"; //对的
            printHelloWorld2(); //对的
    
            System.out.println(score); //对的
            printPass2(); //对的
    
            System.out.println(this); //对的
        }
    }

#### 5、static应用（代码块） ####

接下来我们再补充讲解一个知识点，叫代码块；代码块根据有无static修饰分为两种：静态代码块、实例代码块。

##### 5.1 静态代码块 #####

*  格式：static \{ \}
 *  特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
 *  作用：完成类的初始化，例如：对类变量的初始化赋值。

public class Student {
        static int number = 80;
        static String schoolName = "黑马";
        // 静态代码块
        static {
            System.out.println("静态代码块执行了~~");
            schoolName = "黑马";
        }
    }

静态代码块不需要创建对象就能够执行

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); // 黑马
        }
    }

运行结果：

![71968db5689648f49192737845f26ea9.png][]

发现没有创建对象，静态代码块就已经执行了。

关于静态代码块重点注意：**静态代码块，随着类的加载而执行，而且只执行一次。**

##### 5.2 实例代码块 #####

*  格式：\{ \}
 *  特点：每次创建对象时，执行实例代码块，饼子啊构造器前执行。
 *  作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

实例代码块的作用和构造器的作用是一样的，用来给对象初始化值；而且每次创建对象之前都会先执行实例代码块。

public class Student{
        //实例变量
    	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) {
            Student s1 = new Student();
            Student s2 = new Student("张三");
            System.out.println(s1.age);
            System.out.println(s2.age);
        }
    }

对于实例代码块重点注意：**实例代码块每次创建对象之前都会执行一次** 。

#### 6、static应用（单例设计模式） ####

所谓设计模式指的是，一类问题可能会有多种解决方案，而设计模式是在编程实践中，多种方案中的一种最优方案。

### 二、继承 ###

#### 1、继承快速入门 ####

面向对象的三大特征：**封装**、**继承**、**多态**。

![52d8b3fbe9954ade8256a3d939b65471.png][]

接下来，我们演示一下使用继承来编写代码，注意观察继承的特点。

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

然后，写一个B类，让B类继承A类。在继承A类的同时，B类中新增一个方法print3

public class B extends A{
        public void print3(){
            // 由于i和print1是属于父类A的公有成员，在子类中可以直接被使用
            System.out.println(i); // 正确
            print1(); // 正确
            
            // 由于j和print2是属于父类A的私有成员，在子类中不可以被使用
            // System.out.println(j); // 错误
            print2();
        }
    }

接下来，我们再演示一下，创建B类对象，能否调用父类A的成员。再写一个测试类

public class Test{
        public static void main(String[] args){
            B b = new B();
            // 父类公有成员，子类对象是可以调用的
            System.out.println(i); // 正确
            b.print1();
            
            // 父类私有成员，子类对象时不可以调用的
            // System.out.println(j); // 错误
            // b.print2(); //错误 
        }
    }

为了让大家对继承有更深入的认识，我们来看看继承的内存原理。

这里我们只需要关注一点：**子类对象实际上是由子、父类两张设计图共同创建出来的。**

所以，在子类对象的空间中，既有本类的成员，也有父类的成员。但是子类只能调用父类公有的成员。

![eea9d3cecee84acba9b20daa8faa655e.png][]

#### 2、继承的好处 ####

我们通过一个案例来学习继承的好处，以及它的应用场景。

![cb109294c9a646899251b45a9c927cb4.png][]

观察代码，我们会发现Teacher类中和Consultant类中有相同的代码；其实像这种两个类中有相同代码时，没必要重复写。我们可以把重复的代码提取出来，作为父类，然后让其他类继承父类就可以了，这样可以提高代码的复用性。改造后的代码如下：

![8c1ef472dc80476899fbe7e144ca9046.png][]

关于继承的好处我们只需要记住：**继承可以提高代码的复用性** 。

#### 3、权限修饰符 ####

在刚才使用继承编写的代码中我们有用到两个权限修饰符，一个是public（公有的）、一个是private（私有的），实际上还有两个权限修饰符，一个是protected（受保护的）、一个是缺省的（不写任何修饰符）。

> **什么是权限修饰符呢？**
> 
> 权限修饰符是用来限制类的成员（成员变量、成员方法、构造器...）能够被访问的范围。

每一种权限修饰符能够被访问的范围如下：

![e07f97d5c6a544458eee41b2b8fbd220.png][]

下面我们用代码演示一下，在本类中可以访问到哪些权限修饰的方法。

public class Fu {
        // 1、私有:只能在本类中访问
        private void privateMethod(){
            System.out.println("==private==");
        }
    
        // 2、缺省：本类，同一个包下的类
        void method(){
            System.out.println("==缺省==");
        }
    
        // 3、protected: 本类，同一个包下的类，任意包下的子类
        protected void protectedMethod(){
            System.out.println("==protected==");
        }
    
        // 4、public： 本类，同一个包下的类，任意包下的子类，任意包下的任意类
        public void publicMethod(){
            System.out.println("==public==");
        }
    
        public void test(){
            //在本类中，所有权限都可以被访问到
            privateMethod(); //正确
            method(); //正确
            protectedMethod(); //正确
            publicMethod(); //正确
        }
    }

接下来，在和Fu类同一个包下，创建一个测试类Demo，演示同一个包下可以访问到哪些权限修饰的方法。

public class Demo {
        public static void main(String[] args) {
            Fu f = new Fu();
            // f.privateMethod();	//私有方法无法使用
            f.method();
            f.protectedMethod();
            f.publicMethod();
        }
    }

接下来，在另一个包下创建一个Fu类的子类，演示不同包下的子类中可以访问哪些权限修饰的方法。

public class Zi extends Fu {
        //在不同包下的子类中，只能访问到public、protected修饰的方法
        public void test(){
            // privateMethod(); // 报错
            // method(); // 报错
            protectedMethod();	//正确
            publicMethod();	//正确
        }
    }

接下来，在和Fu类不同的包下，创建一个测试类Demo2，演示一下不同包的无关类，能访问到哪些权限修饰的方法。

public class Demo2 {
        public static void main(String[] args) {
            Fu f = new Fu();
            // f.privateMethod(); // 报错
            // f.method();		  //报错
            // f.protecedMethod();//报错
            f.publicMethod();	//正确
    
            Zi zi = new Zi();
            // zi.protectedMethod();
        }
    }

#### 4、单继承、Object ####

**Java语言只支持单继承，不支持多继承，但是可以多层继承**。就像家族里儿子、爸爸和爷爷的关系一样：一个儿子只能有一个爸爸，不能有多个爸爸，但是爸爸也是有爸爸的。

public class Test {
        public static void main(String[] args) {
            // 目标：掌握继承的两个注意事项事项。
            // 1、Java是单继承的：一个类只能继承一个直接父类；
            // 2、Object类是Java中所有类的祖宗。
            A a = new A();
            B b = new B();
    
            ArrayList list = new ArrayList();
            list.add("java");
            System.out.println(list.toString());
        }
    }
    
    class A {} //extends Object{}
    class B extends A{}
    // class C extends B , A{} // 报错
    class D extends B{}

#### 5、方法的重写 ####

> **什么是方法重写？**
> 
> 当子类觉得父类方法不好用，或者无法满足父类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。
> 
> **注意：重写后，方法的访问遵循就近原则**。

下面我们看一个代码演示：

写一个A类作为父类，定义两个方法print1和print2。

public class A {
        public void print1(){
            System.out.println("111");
        }
    
        public void print2(int a, int b){
            System.out.println("111111");
        }
    }

再写一个B类作为A类的子类，重写print1和print2方法。

public class B extends A{
        // 方法重写
        @Override // 安全，可读性好
        public void print1(){
            System.out.println("666");
        }
    
    
        // 方法重写
        @Override
        public void print2(int a, int b){
            System.out.println("666666");
        }
    }

接下来，在测试类中创建B类对象，调用方法。

public class Test {
        public static void main(String[] args) {
            // 目标：认识方法重写，掌握方法重写的常见应用场景。
            B b =  new B();
            b.print1();
            b.print2(2, 3);
        }
    }

执行代码，我们发现真正执行的是B类中的print1和print2方法。

![c8ac9ea2b3a44fe6826c539b94652e25.png][]

> **注意事项：**
> 
> 1.  重写的方法上面，可以加一个注解@Override,用于标注这个方法是复写的父类方法
> 2.  子类复写父类方法时，访问权限必须大于或者等于父类方法的权限
> 3.  public > protected > 缺省
> 4.  重写的方法返回值类型，必须与被重写的方法返回值类型一样，或者范围更小
> 5.  私有方法、静态方法不能被重写，如果重写会报错。

实际上我们写代码时，只要和父类写的一样就可以（ 总结起来就8个字：**声明不变，重新实现**）。

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

比如：有一个Student类，这个类会默认继承Object类。

public class Student extends Object{
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

其实Object类中有一个toString()方法，直接通过Student对象调用Object的toString()方法，会得到对象的地址值。

public class Test {
        public static void main(String[] args) {
            Student s = new Student("播妞", 19);
            // System.out.println(s.toString());
            System.out.println(s);
        }
    }

![3a55ab540a56442bb3fe84e3da99dd6a.png][]

但是，此时不想调用父类Object的toString()方法，那就可以在Student类中重新写一个toSting()方法，用于返回对象的属性值。

重新运行测试类，结果如下：

![2038d5a1837e403ba8f2256ab79da06d.png][]

#### 6、子类中访问成员的特点 ####

刚才我们已经学习了继承，我们发现继承至少涉及到两个类，而每一个类中都可能有各自的成员（成员变量、成员方法），就有可能出现子类和父类有相同成员的情况，那么在子类中访问其他成员有什么特点呢？

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

定义一个父类，代码如下 ：

public class F {
        String name = "父类名字";
    
        public void print1(){
            System.out.println("==父类的print1方法执行==");
        }
    }

再定义一个子类，代码如下。有一个同名的name成员变量，有一个同名的print1成员方法；

public class Z extends F {
        String name = "子类名称";
        public void showName(){
            String name = "局部名称";
            System.out.println(name); // 局部名称
        }
    
        @Override
        public void print1(){
            System.out.println("==子类的print1方法执行了=");
        }
    
        public void showMethod(){
            print1(); // 子类的
        }
    }

接下来写一个测试类，观察运行结果，我们发现都是调用的子类变量、子类方法。

public class Test {
        public static void main(String[] args) {
            // 目标：掌握子类中访问其他成员的特点：就近原则。
            Z z = new Z();
            z.showName();
            z.showMethod();
        }
    }

*  如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super进行区分。

public class Z extends F {
        String name = "子类名称";
    
        public void showName(){
            String name = "局部名称";
            System.out.println(name); // 局部名称
            System.out.println(this.name); // 子类成员变量
            System.out.println(super.name); // 父类的成员变量
        }
    
        @Override
        public void print1(){
            System.out.println("==子类的print1方法执行了=");
        }
    
        public void showMethod(){
            print1(); // 子类的
            super.print1(); // 父类的
        }
    }

#### 7、子类中访问构造器的特点 ####

我们知道一个类中可以写成员变量、成员方法，还有构造器。在继承关系下，子类访问成员变量和成员方法的特点我们已经学过了；接下来再学习子类中访问构造器的特点。

> **子类中访问构造器的语法规则：**
> 
>  *  首先，子类全部构造器，都会先调用父类构造器，再执行自己。

执行顺序，如下图按照① ② ③ 步骤执行：

![6b8cbc0ca55147429e1bfc3d89f11a47.png][]

> **子类访问构造器的应用场景：**
> 
>  *  如果不想使用默认的super()方式调用父类构造器，还可以手动使用super(参数)调用父类有参数构造器。

![bad61255d5144a32bb2e7af82435a0af.png][]

> **在本类中访问自己的构造方法** ：
> 
> 刚才我们学习了通过super()和super(参数)可以访问父类的构造器。有时候我们也需要访问自己类的构造器。语法如下：
> 
>  *  this()：调用本类的空参数构造器
>  *  this(参数)：调用本类有参数的构造器

![f1b0d989734d4196915a3425a706c7e0.png][]

> **this和super总结：**
> 
> 访问本类成员：  
>  this.成员变量 // 访问本类成员变量  
> this.成员方法 // 调用本类成员方法  
> this()   // 调用本类空参数构造器  
> this(参数)  // 调用本类有参数构造器  
>   
> 访问父类成员：  
> super.成员变量 // 访问父类成员变量  
> super.成员方法  // 调用父类成员方法  
> super()  // 调用父类空参数构造器  
> super(参数)   // 调用父类有参数构造器  
>   
> **注意：this和super访问构造方法，只能用到构造方法的第一句，否则会报错。**

[522b2c8692a348d999b489dc221460fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/663afd4b52c24d45bd91b49497bd6340.png
[50ebbad32da24a20936264e460df471f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/7a1f891d0a154b648c20472717e957a4.png
[4f71dd72bca24ef38bf517478bea315f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/a8a5a85175e044249872cb61097fdf5f.png
[2a006926204b40f281dc9d6c1467771d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/ec9bcc1b4f5749dfb88034eb59e2b667.png
[fb80705cacf44d63b4b030b3cefd5307.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/02487db706cd407285dafadb5d8f5604.png
[cae891164c614dd69ae93f12775541bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/1d7f8b9fc3e849b1ba8920f9a951a808.png
[71968db5689648f49192737845f26ea9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/8b49db0955604694b4ef5ec4f149f11d.png
[52d8b3fbe9954ade8256a3d939b65471.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/dff21bafcfbf41249e8a486f0af0f2ce.png
[eea9d3cecee84acba9b20daa8faa655e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/050f1feb922441398e4c861c5b44479a.png
[cb109294c9a646899251b45a9c927cb4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/f090cffa8aa649ffa13ad5b89b1b5f3e.png
[8c1ef472dc80476899fbe7e144ca9046.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/4cac08caf6684cde8cf77a8422b45750.png
[e07f97d5c6a544458eee41b2b8fbd220.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/9701175cc8b3406aaa14017bb520bd99.png
[c8ac9ea2b3a44fe6826c539b94652e25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/92cb534ccb1f4b3892c88410aa3b8122.png
[3a55ab540a56442bb3fe84e3da99dd6a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/c6af5bd3c0064f8692e1669e36a464e9.png
[2038d5a1837e403ba8f2256ab79da06d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/a15cd9dc977e46dc97d7c1a948c2a7b0.png
[6b8cbc0ca55147429e1bfc3d89f11a47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/39ff8cad9e844ce2b88036b453fb2fc2.png
[bad61255d5144a32bb2e7af82435a0af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/eb46b5cbb9eb4dd5a89b1dbb309de9ac.png
[f1b0d989734d4196915a3425a706c7e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/d4f877f809ec4b94805ecd0757300956.png