一、static
1.static是什么？
-
static是静态，可以修饰成员变量和成员方法；
-
static修饰成员变量，表示该成员变量内存中只存一份，可以被共享访问、修改；
2.静态成员变量
2.1.静态成员变量访问方法
类名.静态成员变量（推荐）对象.静态成员变量
2.2.成员变量分两类
| 静态成员变量 | 实例成员变量 |
|---|---|
| static修饰，属于类，内存中加载一次 | 无static修饰，存在每个对象中 |
| 常表示在线人数信息等需要共享的信息，可以被共享访问 | 对象.实例成员变量 |
2.3.static修饰成员变量的内存原理
在main方法执行前，静态成员变量在堆内存中的静态变量区直接创建。
3.静态方法
3.1 成员方法分类
| 分类 | 访问方式 | 访问特点 | 备注 | |
|---|---|---|---|---|
| 静态成员方法 | static修饰，归属类 | 建议类名访问，也可以对象访问； | 同一类中访问静态方法，类名可以省略； | 执行一个共用功能（工具类），可以申明静态; |
| 实例成员方法 | 无static，归属对象 | 只能对象访问；表示对象自己的行为，且要访问实例变量，必须申明实例方法 | 可以直接访问实例成员变量 |
3.2静态方法内存原理
- 静态方法和main一起优先加载到方法区；
- 加载到栈内存执行
- 如果是通过对象方法（new，无论是否静态），要先到堆内存中找到对象，再找到实例方法
4.static访问注意事项
- 静态方法只能访问静态成员，不可以直接访问实例成员；
- 实例方法可以访问静态成员，亦可以访问实例成员；
- 静态方法中不可以出现this关键字（this表示当前对象地址）
5.工具类
工具类中都是一些静态方法，以完成一个共用功能为目的，给开发人员共同使用
5.1工具类定义要求：
-
工具类用静态方法，类名直接访问，无需创建对象，建议将工具类构造器私有化；
-
private LoginUtil(){ //无法再new }
-
5.2 工具类练习
public class ArraysUtils {
/**
* 输出数组[10,20,30,40,100]
* @param arr
* @return
*/
public static String toString(int[] arr){
//校验
if (arr == null){
return null;
}
String data ="[";
for (int i = 0; i < arr.length; i++) {
data += i==arr.length-1 ? arr[i]:arr[i]+",";
}
data += "]";
return data;
}
/**
* 去掉最大最小，取平均值
* @param a
* @return
*/
public static double getAerage(double[] a){
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-1-i; j++) {
if (a[j]>a[j+1]){
double temp = a[j] ;
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(a));
double data=0.0;
for (int i = 1; i <a.length-1 ; i++) {
data += a[i];
}
return data/(a.length-2);
}
}
6.代码块
6.1概述
- 代码块是类五大成分之一（成员变量，构造器，方法，代码块，内部类）
- 定义在类中，方法外
- 使用{括起来的代码称为代码块}
6.2 代码块分类
| 分类 | 格式 | 特点 | 使用场景 |
|---|---|---|---|
| 静态代码块 | static{} | 随着类加载，自动触发，只执行一次 优先加载，在main前 | 类加载时，做一些静态的数据初始化 |
| 构造（实例）代码块 | {} | 每次创建对象，调用构造器执行时，在构造器执行前，执行块内代码 | 初始化实例资源 |
6.3 静态代码块实例
public class Test01 {
/**
* 定义一个静态集合 ，集合只加载一个，因为当前房间只需要一副牌
*/
public static ArrayList<String> cards = new ArrayList<>();
/**
* 程序运行前，将54张牌放进去
* @param args
*/
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);
}
}
7.单例设计模式
7.1什么是设计模式？
- 开发中问题有n中解法，最优解法被总结出来，称为设计模式
- 设计模式有20多种，对应20多种软件开发中问题
- 设计模式主要学两点：
- 用来解决什么问题
- 怎么写，如何解决问题
7.2 单例模式
- 保证系统中，应用该模式的类用于只有一个实例，一个类永远只能创建一个对象；
- 如，任务管理器对象，只需一个，节省内存空间；
7.3单例实现方式
| 方式 | 特点 |
|---|---|
| 饿汉式 | 定义一个类，构造器私有 定义一个静态变量存储一个对象； |
| 懒汉式 | 需要该对象，才去创建对象（延迟加载对象） 构造器私有；定义一个静态变量存储一个对象 提供一个返回单例对象的方法； |
| 线程安全懒汉式 | 双重检测加锁 |
7.3.1 饿汉式
/**
* 饿汉式：
*/
public class SingleInstance {
public static SingleInstance instance = new SingleInstance();
/**
* 构造器私有，拒绝new对象
*/
private SingleInstance(){
}
}
7.3.2 懒汉式
/**
* 懒汉式：
*/
public class SingleInstance2 {
//懒汉式一定要私有化，不允许直接访问取null
private static SingleInstance2 instance;//null
//提供一个返回单例对象的方法；
public static SingleInstance2 getInstance(){
if (instance==null){
//第一次拿，需要创建
instance = new SingleInstance2();
}
return instance;
}
//构造器私有，拒绝new对象
private SingleInstance2(){
}
}
7.3.3 线程安全懒汉式
/**
* 懒汉式：双重检测加锁
*/
public class SingleInstance2 {
//懒汉式一定要私有化，不允许直接访问取null
private static SingleInstance2 instance;//null
//提供一个返回单例对象的方法；
public static SingleInstance2 getInstance(){
////判断是第一次拿，需要创建
if (instance==null){
//对类加锁，保证线程安全
synchronized (SingleInstance2.class) {
//判断其他线程是否创建
if(instance==null)
instance = new SingleInstance2();
}
}
return instance;
}
//构造器私有，拒绝new对象
private SingleInstance2(){
}
二、继承
1.继承是？
- extends关键字，可以使两个类建立父子关系
- 子类（派生类），父类（超类，基类）
- 作用：继承后，子类可以直接使用父类公共的属性和方法；
- 好处：提高代码复用性，增强类的功能扩展性
2.继承设计规范
子类相同特征（属性，方法）放在父类中，子类独有的自己所有
3.继承内存原理
- new对象时，在堆内存开辟空间，同时含有父类空间和子类空间，初始化为null
- 根据调用的成员变量和方法，选择父子空间执行
- super指父类空间地址，this指子类对象地址；
4.继承特点
- 子类可以继承父类属性和行为(方法)，但不能继承父类的构造器；
- 子类有自己构造器
- java是单继承，只能继承一个直接父类；
- java不支持多继承，但支持多层继承；
- java中所有类都是Object类的子类
- 直接继承；默认继承；间接继承
4.1 是否可以继承父类私有成员
子类不可以直接访问父类私有成员；理论上可以继承；
4.2 子类是否可以继承父类静态成员
不算继承，只是共享使用；
5.继承后，成员变量和方法的访问特点
- 就近原则：
- 先子类局部范围（方法内定义变量）找；
- 子类成员范围找；
- 父类成员范围找，找不到报错；
5.1如果子父类中出现重名成员，优先使用子类，一定要用父类怎么办？
可以通过super关键字，指定访问父类成员；
public void showName(){
String name = "局部名";
System.out.println(name);//局部
System.out.println(this.name);//子类
System.out.println(super.name);//父类
}
6.继承后：方法重写
6.1@Override 重写校验注解
class newPhone extends Phone{
@Override //重写校验注解，方法必须是正确重写的，更安全；提高程序可读性
public void call() {
super.call();
System.out.println("打视频电话！！");
}
}
6.2 方法重写要求
- 重写的方法名称，形参列表必须与被重写方法完全一致
- 私有方法不能被重写（@Override报错）
- 子类重写父类方法时，访问权限必须大于或者等于父类（private<缺省<protected<public）
- 子类不能重写父类的静态方法，会报错
- 重写，方法必须过继给子类，静态没有冲突
7.继承后：子类构造器特点
子类中所有构造器（有参无参）默认会先访问父类中无参构造器，再执行自己；
7.1 原因
- 子类初始化，有可能用到父类中数据，如果父类没有完成初始化，子类将无法使用父类数据；
- 子类初始化前，一定调用父类构造器先完成父类数据空间的初始化；
7.2 怎样调用父类构造器
子类构造器第一行默认语句是：super()；不写也默认存在
8.继承后：子类构造器访问父类有参构造器
8.1 作用
初始化继承自父类信息；
public People(String name, int age) {
this.name = name;
this.age = age;
}
public Student(String name, int age) {
super(name, age);
}
8.2 父类只有有参构造器，没有无参会怎样
报错：默认调用无参构造器，找不到
9.this和super
public Student(String name) {
//调用下方的双参构造器
this(name,"灵术一中");
}
public Student(String name, String schoolName) {
this.name = name;
this.schoolName = schoolName;
}
- 注意点：
- 子类通过this调用本类其他构造器，本类其他构造器会通过super手动调用父类构造器，最终还是调用父类；
- this和super()都只能放在构造器第一行，二者不能共存同以一个构造器中；
RecordDate：2021/08/11
