Javaheima02

Java进阶

static

用法

  • static修饰的静态成员变量,属于类,只在内存中加载一次,可以被共享访问.常用来表示在线人数信息,等需要被共享的信息
public class User{
    //静态成员变量
    public static String onlineNumber = 161;
    //因为需要共享,所以用public关键字修饰
}
//格式
	//推荐使用类名访问
  User.onlineNumber;
//也可使用对象访问  不推荐
  User user = new User();
  user.onlineNumber;

​ 使用static关键字修饰得到属性,推荐使用类去访问,也可以 用对象去访问(不推荐).

注意:同一个类中静态成员变量的访问可以省略类名

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

​ 无static修饰,属于每个对象必须用对象名.访问

//格式
    public class User{
    //实例成员变量
    private String name;
}
//格式
	//使用类名访问
 // User.name;//错误无法实现
//使用对象访问  
  User user = new User();
  user.name;

内存原理

image-20220510092327957

image-20220510092248667

修饰成员方法的基本用法

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

​ 使用场景 :

​ 表示对象自己的行为的,且方法中需要访问实例成员的,则该 方法必须申明成实例方法

​ 如果该方法是以执行一个共用功能为目的,则可以申明成静 态方法

修饰成员方法的内存机制

image-20220510093843285

image-20220510094022522

访问注意事项

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

应用知识 : 工具类

什么是工具类

​ 类中都是一些静态方法,每个方法都是以完成一个共用的功能为目的,这个类用来给系统开发成员共同使用

为什么工具类中断方法不用实例方法做!

​ 实例方法需要创建对象调用,此时用对象知识为了调用方法,这样只会浪费内存

工具类的好处

  • 内部都是一些静态方法,每个方法完成一个功能.
  • 一次编写,处处可用,提高代码的重用性
工具类定义是的其他要求
  • 由于工具类里面都是静态方法,直接使用类名即可访问,因此,工具类无需创建对象,建议将工具类的构造器私有.

实际应用

image-20220510111216886

ArraysUtils工具类

package com.yu.day02ItHeiMa;

public class ArraysUtils {
    //私有构造器
    private ArraysUtils(){
    }
    public static String toString(int[] objects){
        if(objects==null){
            return null;
        }
        String str = "[";
        for (int i = 0; i <objects.length; i++) {
            //我的正常写法
//            if (i == objects.length-1){
//                str += objects[i];
//            }else{
//                str += objects[i];
//                str += ",";
//            }
            //写法简单
            str += (i==objects.length-1)?objects[i]:objects[i]+",";
        }
        str += "]";
        return str;
    }
    public static float getMax(float[] score){
        float max = score[0];
        for (int i = 1; i < score.length; i++) {
            if(max<score[i]){
                max=score[i];
            }
        }
        return max;
    }
    public static float getMin(float[] score){
        float min = score[0];
        for (int i = 1; i < score.length; i++) {
            if(min>score[i]){
                min=score[i];
            }
        }
        return min;
    }
    public static float getAverage(float[] score){
        float average;
        float max = getMax(score);
        float min = getMin(score);
        float sum = 0;
        for (int i = 0; i < score.length; i++) {
            sum += score[i];
        }
        average = (sum-max-min)/(score.length-2);
        return average;
    }
}

实现类

package com.yu.day02ItHeiMa;

public class TestDemo {
    public static void main(String[] args) {
        //问题1
        int[] ints = {10,20,30,50,32,100};
        int[] ints1={};
        int[] ints2=null;
        //调用方法并接收
        String str = ArraysUtils.toString(ints);
        String str1 = ArraysUtils.toString(ints1);
        String str2 = ArraysUtils.toString(ints2);
        //输出
        System.out.println(str);
        System.out.println(str1);
        System.out.println(str2);
        //问题2
        float[] score = {(float)99.7, (float) 99.8,(float)99.9,100,99};
        //求出平均值直接输出
        System.out.println(ArraysUtils.getAverage(score));
    }
}

应用知识 : 代码块

代码块的分类和作用
代码块的概述
  • 代码块是类的五大成分之一(成员变量,构造器,方法,代码块,内部类).定义在类中方法外,
  • 在Java类下,使用{}括起来的代码被称为代码块
代码块分为
  • 静态代码块
    • 格式:static{}
    • 特点:需要通过static关键字修饰,随着类的加载而加载,并且自动触发,只执行一次
    • 使用场景: 在类加载的时候做一些静态初始化的操作,以便以后的使用
  • 构造代码块(了解,见的少)
    • 格式:{}
    • 特点:每次创建对象,调用构造器执行时,都会执行该代码块的代码,并且在构造器执行前执行
    • 使用场景:初始化实例资源
静态代码块的作用

​ 如果要在启动系统时对静态字眼进行初始化,则建议使用静态代码完成数据的初始化操作.

应用知识:单列设计模式

设计模式

​ 开发中经常遇到的一些问题,一个问题通常由n种解法,但其中肯定有一种解法是最优的,这个最优的解法被人总结出来了,称之为设计模式

​ 设计模式有20多种

学设计模式主要学两点

  • 这种模式用来解决声明问题
  • 遇到这种问题了,该模式是怎么写的,他是如何解决这个问题的.
单例模式
  • 可以保证系统中,应用该模式的这个类永远只有一个实例,即一个类永远只能创建一个对象
  • 例如任务管理器对象,我们只需要一个就可以解决问题了,这样可以节省内存空间

单例的实现方式很多

  • 饿汉单例模式
  • 懒汉单例模式
  • 等

饿汉单例模式

  • 在用类获取对象的时候,对象以经提前为你创建好了

设计步骤

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

/**
 * 使用饿汉单例实现单例类
 */
public class singleinstance {
    /**
     * 2.饿汉单例在获取对象前,对象已经提前准备好了一个,
     * 这个对象只能是一个,所以定义一个静态成岩变量记住
     */

    public static singleinstance instance = new singleinstance();

    /**
     * 1.必须把构造器私有化
     */
    private singleinstance(){
    }
}

package com.yu.SingleInstance;

public class Test {
    public static void main(String[] args) {
        //理解饿汉单例模式设计步骤
        //因为在上面类中已经建好对象,在这属于直接调用不要加new
        //我加了new 自己找了好久才注意到
        SingleInstance s1 =  SingleInstance.instance;
        SingleInstance s2 =  SingleInstance.instance;
        System.out.println(s1==s2);
    }
}

实现步骤

  • 定义一个类,把构造器私有
  • 定义一个静态变量存储一个对象

懒汉单例模式

  • 在真正需要该对象的时候,才去创建一个对象(延迟加载对象)

设计步骤

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

/**
 * 懒汉单例
 */
public class SingleInstance2 {
    /**
     * 2.定义一个静态的成员变量负责存一个对象
     * 懒汉单例注意对象私有化
     * 这样可以避免给别人挖坑
     */
    private static SingleInstance2 instance2;
    /**
     * 3.提供一个方法,对外返回单例对象
     */
    public static SingleInstance2 getInstance2(){
        if(instance2 == null){
            //第一次来拿对象,此时需要创建对象
            instance2 = new SingleInstance2();
        }
        return instance2;
    }
    /**
     * 1.构造器私有化
     */
    private SingleInstance2(){}
}

package com.yu.SingleInstance;

public class Test2 {
    public static void main(String[] args) {
        //懒汉单例模式的设计,理解其思想
        SingleInstance2 s1 = SingleInstance2.getInstance2();
        SingleInstance2 s2 = SingleInstance2.getInstance2();
        System.out.println(s1);
        System.out.println(s2);
    }
}

继承(extends)

​ 是Java允许我们用extends关键字,让一个类和另一个类建立起一种父子关系

Java中子类更加强大

作用

当子类继承父类后,就可以直接使用父类公共的属性和方法了

好处

  • 可以提高代码的复用性
  • 减少代码冗余
  • 增强类的功能扩展性

设计规范

  • 子类们相同特征(共同属性,共性方法)放在父类中定义

  • 子类独有的属性和行为应该定义在子类自己里面

 posted on 2022-05-11 08:44  yulll  阅读(22)  评论(0)    收藏  举报