黑马程序员Java教程学习笔记

Posted 末初mochu7

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了黑马程序员Java教程学习笔记相关的知识,希望对你有一定的参考价值。

学习视频:https://www.bilibili.com/video/BV1Cv411372m
如侵权,请私信联系本人删除

文章目录


黑马程序员Java教程学习笔记(四)

static:修饰成员变量、内存机制

static是什么?

  • static修饰成员变量表示该成员变量只在内存中只存储一份,可以被共享访问、修改

成员变量可以分为一下两类

第一类:静态成员变量(有static修饰,属于类,内存中加载一次):常表示如在线人数等信息,可以被共享访问。

public class User
	// 静态成员变量
	public static String onlineNumber = 161;

两种访问方法:
类名.静态成员变量 (推荐)
对象.静态成员变量 (不推荐)
package com.mochu.d1_static;

public class User 
    /**
     * 在线人数
     * static修饰成员变量、静态成员变量、在内存中只有一份,可以共享
     */
    public static int onlineNumber = 161;

package com.mochu.d1_static;

public class StaticFieldDemo1 
    public static void main(String[] args) 
        // 理解static修饰成员变量和访问特点
        // 类名.静态成员变量
        System.out.println(User.onlineNumber);

        // 对象.静态成员变量
        User u = new User();
        System.out.println(u.onlineNumber);
    

第二类:实例成员变量(无static修饰,存在于每个对象中):常表示姓名name、年龄age、等属于每个对象的信息。

只能用以下这种方法访问

对象.实例成员变量
package com.mochu.d1_static;

public class User 
    /**
     * 在线人数
     * static修饰成员变量、静态成员变量、在内存中只有一份,可以共享
     */
    public static int onlineNumber = 161;

    /**
     * 实例成员变量,无static修饰,属于每个对象,必须用对象名.访问
     */
    private int age;
    private String name;

    public static void main(String[] args) 
        User u = new User();
        u.name = "mochu7";
        u.age = 21;
        System.out.println(u.name);
        System.out.println(u.age);
        // 同一个类中访问静态成员变量可以不用加类名
        System.out.println(onlineNumber);
    

Static修饰成员变量的内存原理

static:修饰成员方法、内存机制

成员方法的分类:

  • 静态成员方法(有static修饰,归属于类),建议用类名访问,也可以用对象访问。
  • 实例成员方法(无static修饰,归属于对象),只能用对象触发访问。

使用场景:

  • 表示对像自己的行为的,且方法中需要访问实例成员的,则该方法必须申明成实例方法。
  • 如果该方法是以执行一个共用功能为目的,则可以申明成静态方法。

Static修饰成员方法的内存原理

static访问注意事项

  • 静态方法只能访问静态的成员,不可以直接访问实例成员。
  • 实例方法可以访问静态的成员,也可以访问实例成员。
  • 静态方法中是不可以出现this关键字的。
package com.mochu.d1_static;

public class Test 
    // 静态成员
    public static int onlineNumber = 10;

    public static void test2() 
        System.out.println("==test2==");
    

    // 实例成员
    private String name;
    public void run() 
        System.out.println(name + "好好学习");
    

    // 1. 静态方法只能访问静态成员,不能直接访问实例成员(可以创建对象来访问)
    public static void test() 
        System.out.println(Test.onlineNumber);
        System.out.println(onlineNumber);
        Test.test2();
        test2();
        // System.out.println(name); // 不能直接访问实例成员
        // run(); // 不能直接访问实例成员
    

    // 2. 实例方法可以访问静态成员,也可以直接访问实例成员
    public void go() 
        System.out.println(Test.onlineNumber);
        System.out.println(onlineNumber);
        System.out.println(name);
        test();
        run();
        System.out.println(this);
    

    // 3. 静态方法中不可以出现this关键字
    public static void test3() 
        // this只能代表当前对象,而静态方法可以不用对象调用
        // System.out.println(this);
    

    public static void main(String[] args) 

    

static:应用知识-工具类

工具类是什么?

  • 类中都是一些静态方法,每个方法都是以完成一个共用的功能为目的,这个类用来给系统开发人员共同使用。
package com.mochu.d2_static_util;

import java.util.Random;

public class Login 
    public static void main(String[] args) 
        System.out.println("验证码:" + mochuUtil.createVerifyCode(6));
    

package com.mochu.d2_static_util;

import java.util.Random;

public class mochuUtil 
    // 由于工具类无需创建对象,所以将构造器私有
    private mochuUtil() 
    

    public static String createVerifyCode(int n) 
        // 生成验证码
        String code = "";
        String allString = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random rd = new Random();
        for (int i = 0; i < n; i++) 
            int index = rd.nextInt(allString.length());
            code += allString.charAt(index);
        
        return code;
    

package com.mochu.d2_static_util;

public class ArrayUtil 
    // 私有构造器
    private ArrayUtil() 
    

    /**
     * 工具方法:静态方法
     * 功能:展示数组内容
     */
    public static String toString(int[] arr) 
        if(arr == null) 
            return null;
        
        // 拼接内容返回
        String result = "[";
        for (int i = 0; i < arr.length; i++) 
            result += (arr.length - 1 == i ? arr[i] : arr[i] + ", ");
        
        result += "]";
        return result;
    

    /**
     * 工具方法:静态方法
     * 功能:统计平均数
     */
    public static double getAverage(double[] arr) 
        double max = arr[0];
        double min = arr[0];
        double sum = 0;
        double averageNum = 0;
        for (int i = 0; i < arr.length; i++) 
            if(max < arr[i]) 
                max = arr[i];
            
            if(min > arr[i]) 
                min = arr[i];
            
            sum += arr[i];
        
        System.out.println(max);
        System.out.println(min);
        averageNum = (sum - (max + min)) / (arr.length - 2);
        return averageNum;
    

package com.mochu.d2_static_util;

public class TestDemo 
    public static void main(String[] args) 
        int[] arr1 = null;
        int[] arr2 = ;
        int[] arr3 = 12, 34, 56, 78, 90;
        System.out.println(ArrayUtil.toString(arr1));
        System.out.println(ArrayUtil.toString(arr2));
        System.out.println(ArrayUtil.toString(arr3));

        double[] arr4 = 56.8, 77.9, 69.2, 89.5, 72.9, 94.7;
        System.out.println("平均分:" + ArrayUtil.getAverage(arr4));
    

static:应用知识-代码块

代码块概述

  • 代码块是类的五大成分之一(成员变量、构造器、方法、代码块、内部类),定义在类中方法外。
  • 在Java类下,使用括起来的代码被称为代码块。

代码块分为:

  • 静态代码块:
    – 格式:static
    – 特点:需要通过static关键字修饰,随着类的加载而加载,并且自动触发,只执行一次
    – 使用场景:在类加载的时候做一些静态数据初始化的操作,以便后续使用
package com.mochu.d3_static_code;

import java.util.ArrayList;

public class StaticCode 
    public static String name;
    public static ArrayList<String> cards = new ArrayList<>();

    public static void main(String[] args) 
        System.out.println("main方法被执行了");
        System.out.println(name);
        System.out.println(cards);
    

    /**
     * 静态代码块,属于类、与类一起优先加载、自动触发执行
     * 作用:初始化静态资源
     */
    static
        System.out.println("静态代码块被执行了");
        name = "mochu7";
        cards.add("3");
        cards.add("4");
    

  • 构造代码块(实例代码块)(了解,见得少):
    – 格式:
    – 特点:每次创建对象,调用构造器执行时,都会执行该代码块的代码,并且在构造器执行前执行
    – 使用场景:初始化实例资源
package com.mochu.d3_static_code;

public class StaticCode1 
    private String name;

    public StaticCode1() 
        System.out.println("无参构造器被执行");
    
    /**
     * 构造代码块(实例代码块),无static修饰,属于对象,用于初始化实例资源
     */
    
        name = "mochu7";
        System.out.println("构造代码块被执行");
    

    public static void main(String[] args) 
        StaticCode1 test = new StaticCode1();
        System.out.println(test.name);
        StaticCode1 test1 = new StaticCode1();
        System.out.println(test1.name);
    

静态代码块应用案例

package com.mochu.d3_static_code;

import java.util.ArrayList;

public class StaticTest3 
    /**
     * 定义一个静态集合,这个集合只加载一次
     */
    public static ArrayList<String> cards = new ArrayList<String>();

    // 在程序运行前,初始化54张牌
    static
        // 定义一个数组存储点数
        String[] sizes = "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2";
        // 定义一个数组存储花色
        String[] colors = "♠", "♦", "♣", "♥";
        // 组合点数花色
        for (int i = 0; i < sizes.length; i++) 
            for (int j = 0; j < colors.length; j++) 
                String card = sizes[i] + colors[j];
                cards.add(card);
            
        
        cards.add("小王");
        cards.add("大王");
    

    public static void main(String[] args) 
        System.out.println(cards);
    

static:应用知识-单例模式


饿汉单例模式

饿汉单例的实现步骤:

  • 定义一个类,把构造器私有
  • 定义一个静态变量存储一个对象
package com.mochu.d4_static_singleinstance;

/**
 * 使用饿汉单例类
 * 饿汉单例是在获取对象前,对象已经提前准备好了一个。这个对象只能是一个,所以定义静态成员变量记住。
 */
public class SingelInstance 
    public static SingelInstance instance = new SingelInstance();

    private SingelInstance() 
    

package com.mochu.d4_static_singleinstance;

public class Test 
    public static void main(String[] args) 
        SingelInstance ss1 = SingelInstance.instance;
        SingelInstance ss2 = SingelInstance.instance;
        System.out.println(ss1 == ss2);
    

懒汉单例模式

package com.mochu.d4_static_singleinstance;

public class SingelInstance2 
    // 定义一个静态成员变量存储一个对象,只加载一次,在内存中只有一份
    private static SingelInstance2 instance2; // 这里最好私有化,防止被外部直接调用

    //私有化构造器
    private SingelInstance2()
    

    //提供一个方法,对外返回一个单例对象
    public static SingelInstance2 getInstance() 
        if(instance2 == null) 
            // 第一次调用对象,创建对象返回
            instance2 = new SingelInstance2();
        
        return instance2;
    

package com.mochu.d4_static_singleinstance;

public class Test2 
    public static void main(String[] args) 
        SingelInstance2 ss1 = SingelInstance2.getInstance();
        SingelInstance2 ss2 = SingelInstance2.getInstance();
        System.out.println(ss1 == ss2);
    

继承:概述、案例

什么是继承?

  • Java中提供一个关键字extends,用这个关键字,可以让一个类和另一个类建立起父子关系
  • 作用:当子类继承父类后,就可以直接使用父类公共的属性和方法了。
  • 优点:提高代码复用性、减少代码冗余、增强类的功能扩展性。

继承的设计规范、内存运行原理

继承设计规范:

  • 子类们相同特征(共性属性、共性方法)放在父类中定义,子类独有的属性和行为应该定义在子类中。
package com.mochu.d5_extends;

public class People 
    private

以上是关于黑马程序员Java教程学习笔记的主要内容,如果未能解决你的问题,请参考以下文章

黑马程序员Java教程学习笔记

黑马程序员Java教程学习笔记

黑马程序员Java教程学习笔记

黑马程序员Java教程学习笔记

黑马程序员Java教程学习笔记

黑马程序员Java教程学习笔记