JavaSE进阶

static关键字的作用                                                                

static是静态的意思,可以修饰成员变量,表示该成员变量在内存中只存储一份,可以被共享访问.修改

成员方法的分类：

静态成员方法（有static修饰，属于类），建议用类名访问，也可以用对象访问

实例成员方法（无static修饰，属于对象），只能用对象触发访问

使用场景：

工具类:对于一些应用程序中多次需要用到的功能,可以将这些功能封装成静态方法,放在一个类中,这个类就是工具类

工具类的作用:一是方便调用,二是提高了代码复用.

工具类的延伸:建议将工具类的构造器私有(private),不让工具类对外产生对象,若产生对象则会浪费内存,所以工具类中的方法我们不用实例方法做,因为实例方法需要创建对象进行调用,此时用对象只为了调用方法,只会浪费内存

static访问注意事项:

静态方法只能访问静态的成员,不可以直接访问实例成员(需要创建对象才能访问)

实例方法可以访问静态的成员, 也可以访问实例成员

静态方法中是不可以出现this关键字的

代码块概述:

代码块是类的五大部分之一(成员变量,方法,构造器,代码块,内部类),定义在类中方法外

在Java类下,使用 { } 括起来的代码被称为代码块

代码块分为:

静态代码块: 

   格式:static{ } 

   特点:需要通过static关键字修饰,随着类的加载而加载,并且自动触发,只执行一次

   使用场景:在类加载的时候做一些静态数据初始化的操作,以便后续使用

构造代码块(了解,用的少):

   格式: { }

   特点:每次创建对象,调用构造器执行时,都会执行该代码中的代码,并且在构造器执行前执行

   使用场景:初始化实例资源

设计模式是一套前人反复使用且多人知.经过分类编目的代码设计经验的总结,后来者可以直接用来解决问题,好的设计模式可以进一步提高代码的复用性  

单例模式为设计模式中的一种:可以保证系统中,应用该模式的这个类永远只有一个实例,即一个类只能创建一个对象(对象即是实例,实例即是对象)

单例的场景:例如任务管理器对象我们只需要一个就可以解决问题了

单例的作用:节省内存空间

单例实现方式有很多,如:

●饿汉单例设计模式:在用类获取对象的时候,对象已经提前为你创建好了（提前创建对象则节约了时间，但不知道到底最终需不需要这个对象，则有浪费了内存的隐患）           

       设计步骤:1.定义一个类,把构造器私有.    2.定义一个静态变量存储一个对象

//定义一个单例类
public class SingleInstance1 {
    /**
     * 2.定义一个公开的静态成员变量存储一个类的对象,属于类,与类一起加载一次
     * 饿汉:在这里加载静态变量的时候就会创建对象
     * public static int onLineNumber = 161;
     */
    //这里用public是为了让别人去访问
    public static SingleInstance1 instance = new SingleInstance1();

    /**
     * 1.单例必须把构造器私有起来
     */
    private SingleInstance1() {
    }
}

●懒汉单例设计模式:在真正需要该对象的时候,才去创建一个对象(延迟加载对象,则牺牲了时间去节约了内存)

       设计步骤:1.定义一个类,把构造器私有.    2.定义一个静态变量存储一个对象

                       3.提供一个返回单例对象的方法

public class SingleInstance2 {
    /**
        2.创建一个静态成员变量存储本类的对象,注意,:此时不创建对象
     */
    //最好私有!
    private static SingleInstance2 instance ; //null

    /**
        1.私有构造器
     */
    private SingleInstance2(){
    }

    /**
      3.定义一个方法,让其他地方可以来调用获取一个对象
     */
    public static SingleInstance2 getInstance(){
        if(instance == null){
            //第一次来获取对象
            instance = new SingleInstance2();
        }
        return instance;
    }

 面向对象之二是继承,继承是类与类之间的一种关系.多个类继承单独的某个类,多个类就可以使用单独这个类中的属性和行为了.多个类称为子类(派生类),单独的这个类称为父类(基类或超类) 

继承的格式:在Java中,继承的关键字用的是"extends"

public class 子类名 extends 父类名{ } 

 继承的特点:

1.子类是可以继承父类的属性和行为,但是子类不能继承父类的构造器，父类构造器用于初始化父类对象

2.一个类只能继承的一个直接父类

3.不能多继承,但是可以多层继承(即甲可以继承乙,乙可以继承丙,则甲也继承了丙的功能)

4.Java中所有的类都是Object类的子类

5.子类可以继承父类的私有成员,但是不能直接访问

6.子类不可以继承父类中静态成员变量和方法的,但是父类可以共享给子类用,即借给子类用的,但不属于子类,共享并非继承

Object特点:Java中所有的类,要么直接.要么默认.要么间接继承Object,Object是祖宗类

在子类方法中访问成员(成员变量,成员方法)满足:就近原则

优先顺序:子类局部范围>子类成员范围>父类成员范围,若都没有找到则报错

若子父类中,出现了重名的成员,想在子类中使用父类的成员,可以在子类中定义个中转方法通过super关键字来指定访问父类的成员

格式:super.父类成员变量/父类成员方法            

方法重写:在继承体系中,子类出现了和父类一模一样的方法声明,我们就称子类这个方法为重写的方法

方法重写的应用场景:1.当子类需要父类的功能,但父类的该功能不完全满足自己的需求时

                                  2.子类可以重写父类中的方法

@Override重写注释:

1.@Override是放在重写后的方法上,作为重写是否正确校验注解

2.加上该注解后如果重写错误会在编译阶段报错

3.建议重写方法都加@Override注解

方法重写的注意事项和要求:

1.重写方法的名称.形参列表必须与被重写方法的名称和参数列表保持一致

2.私有方法不能被重写

3.子类重写父类方法时,访问权限必须大于或等于父类.(缺省<protected<public)

4.子类不能重写父类的静态方法,若重写加上@Override会校验出错误,因为子类不能继承父类的静态方法

子类继承父类后构造器的特点:

子类中所有的构造器默认都会先访问父类中的无参构造器，再执行自己的构造器。原因：1子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，父类将无法使用父类的数据.2.子类在初始化之前，一定要调用父类构造器先完成父类数据空间的初始化

●子类调用父类构造器的原理：子类构造器的第一行语句默认都是：super（），不写也存在

 super调用父类的有参构造器来初始化继承自父类的数据    

this:代表本类对象的引用; super:代表父类存储空间的标识

   

this(...)和super(...)使用注意点:

子类通过this(...)去调用本类的其他构造器,本类其他构造器会通过super去手动调用父类的构造器,最终还是会调用父类构造器的

注意:this(...) super(...)都只能放在构造器的第一行,所以二者不能共存在同一个构造器中

包是用来分门别类的管理各种不同类的,类似于文件夹,建包利于程序的管理和维护

建包的语法格式:package 公司域名倒写.技术名称  （包名建议全部英文小写且具有意义)

package com.geoffrey.javabean; (javabean就属于技术名称)

public class Student{ } 

导包

●相同的包下的类可以直接访问,不同包下的类必须导包才可以使用 ! 导包格式:import 包名.类名;

●假如一个类中需要用到不同类,而这两个类的名称是一样的,那么默认只能导入一个类,另一个类要带包名访问

权限修饰符：是用来控制一个成员能够被访问的范围的。可以修饰成员变量.方法.构造器.内部类,不同权限修饰符修饰的成员能够被访问的范围将受到限制

权限修饰符的分类和具体作用范围:

有四种作用范围从小到大: ( private->缺省(即什么都不写)->protected->public ) 

 定义成员(方法.成员变量.构造器等)一般满足以下要求:

●成员变量一般private私有

●方法一般public公开

●若该成员只希望本类访问, 使用private修饰

●若该成员只希望本类,同一个包下的其他类和子类访问,使用protected修饰

final的作用

● final关键字可以修饰(方法,变量,类)

● 修饰方法:表明该方法是最终方法,不能被重写

● 修饰变量:表示该变量第一次赋值后,不能再次被赋值(有且仅能被赋值一次,且必须赋值)

● 修饰类:表明该类是最终类,不能被继承

final修饰变量注意点:

● final修饰的变量是基本类型:那么变量存储的数据值不能发生改变

● final修饰的变量是引用类型:那么变量存储的地址值不能发生改变,但是地址指向的对象内容是可以发送改变的

常量

● 常量是使用了public static final修饰的成员变量,必须有初始值,而且执行的过程中其值不能被改变

● 常量的作用和好处: 可以用于做系统的配置信息,方便程序的维护,同时也能提高可读性

常量命名规范:英文单词全部大写,多个单词下划线连接起来

枚举的作用: 是为了做信息的标志和信息的分类

定义枚举类的格式:

修饰符 enum 枚举名称  {

        第一行都是罗列枚举类实例的名称

                                                                }

枚举的特征: 

● 枚举类都是继承了枚举类型: java.lang.Enum

● 枚举都是最终类, 不可以被继承

● 枚举的构造器都是私有的, 枚举对外不能创建对象

● 枚举类的第一行默认都是罗列枚举对象的名称的 

● 枚举类相当于是多例模式

抽象类

● 某个父类知道其所有子类要完成某功能, 但是每个子类完成情况都不一样, 父类就只定义该功能的基本要求,具体实现由子类完成,这个类就可以是一个抽象类,抽象类其实就是一种不完全的设计图

● 抽象类必须使用abstract修饰:

修饰符 abstract class 类名{ }

抽象方法: 

● 就是抽象类中定义的子类必须完成的功能和基本要求 (基本要求的格式: 修饰符 abstract 返回值类型 方法名称(形参列表); 即要求子类必须完成某项功能 )

● 没有方法体, 只有方法签名, 必须abstract修饰

抽象的使用总结与注意事项 

● 抽象类用来继承的, 抽象方法是交给子类重写实现的

● 一个类如果继承了抽象类, 那么这个类必须重写完抽象类的全部抽象方法, 否则这个类也必须定义成抽象类

final和abstract是互斥关系:

1.abstract定义的抽象类作为模板让子类继承, final定义的类不能被继承

2.抽象方法定义通用功能让子类重写,final定义的方法子类不能重写

接口的定义与特点

● 接口的格式如下:

接口用关键字interface来定义

public interface 接口名{

        //常量

        //抽象方法

}

● JDK8之前的接口中只能是抽象方法和常量,没有其他成分了

● 接口不能实例化

● 接口中的成员都是public修饰的,写不写都是,因为规范的目的是为了公开化   

接口的用法: ● 接口是用被类实现(implements)的,实现接口的类称为实现类.实现类可以理解成所谓的子类(吕布), 接口可以理解成所谓的父类(干爹,可以一个也可以多个).

● 注意: 接口可以被类单实现,也可以被类多实现

接口实现的注意事项:

● 一个类实现接口, 必须重写完全部接口的全部抽象方法,否则这个类需要定义成抽象类 

● 类与类的关系：单继承

● 类与接口的关系：多实现

● 接口与接口的关系：多继承，一个接口可以同时继承多个接口

接口多继承的作用: 规范合并，整合多个接口为同一个接口，便于子类实现

如以上的图中，若Inter要加入抽象方法去实现功能，则很多个实现类都需要重写新增的方法，会很麻烦，所以JDK8后接口新增了能直接定义有方法体的方法，不需要重写新增的方法，直接在接口中实现该功能，然后实现类去继承

 JDK接口新增的三类方法:

接口的注意事项:

面向对象三大特征之三: 多态

多态: 同类型的对象, 执行同一个行为, 会表现出不同的行为特征

多态的常见形式:

父类类型 对象名称 = new 子类构造器 ;

接口        对象名称 = new 实现类构造器 ;

多态中成员访问特点:

● 方法调用：编译看左边，运行看右边

● 变量调用：编译看左边，运行也看左边。（多态侧重行为多态）

多态的前提：有继承/实现关系；有父类引用指向子类对象；有方法重写

多态的优势：

● 在多态的形式下，右边对象可以实现解耦合，便于扩展和维护

 ● 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利

多态下产生的一个问题: 多态下不能使用子类的独有功能

自动类型转换(从子到父): 子类对象赋值给父类类型的变量指向

强制类型转换(从父到子)

 ● 此时必须进行强制类型转换:  子类 对象变量 = (子类)父类类型的变量

 ● 作用: 可以解决多态下的劣势, 可以实现调用子类独有的功能

 ● 注意: 如果转型后的类型和对象真实类型不是同一种类型, 那么在转换的时候就会出现ClassCastException

Animal t = new Tortoise();

Dog d = (Dog) t;  //出现异常 ClassCastException

Java建议强制转换前使用instanceof判断当前对象的真实类型, 再进行强制转换

变量名 instanceof 真实类型

判断关键字左边的变量指向的对象的真实类型,是否是右边的类型或者是其子类类型,是则返回true,否则返回false

强制类型转换能解决的问题和注意点:

 

 静态内部类

静态内部类的使用场景.特点.访问总结:

 成员内部类(实例内部类/对象内部类)

成员内部类的特点:可以直接访问外部类的静态成员, 实例方法中可以直接访问外部类的实例成员

注意: 在成员内部类中访问所在内部类对象,  格式:  外部类名.this

   class People{
        private int heartbeat = 150;
        //成员内部类
        public class Heart{
            private int heartbeat = 110;
            public void show(){
                int heartbeat = 78;
                System.out.println(heartbeat);  //78
                System.out.println(this.heartbeat); //110
                System.out.println(People.this.heartbeat); //150
            }
        }
    }

卵用~~~

注意:  匿名内部类可以作为方法的实际参数进行传输     (如下代码段)

 Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生会自由泳~~");
            }
        };
        go(s);
        System.out.println("-----------------");
        go(new Swimming() {  //这种形式跟go(s1)一样,只是直接把new Swimming()直接传入go方法
            @Override
            public void swim() {
                System.out.println("老师会蝶泳~~");
            }
        });

By the way:匿名内部类在开发中不是我们主动去定义的,而是别人需要我们写或者我们可以写的时候才会使用.匿名内部类的代码可以实现代码进一步的简化

Object的toString方法:

toString方法的作用:1.默认打印当前对象的地址;  2.让子类重写,以便返回子类对象的内容

Object的equals方法:

注意:若是单纯比较当前对象与另一个对象的地址是否相同,则"=="完全代替"equals",但是equals存在的意义是:父类equals方法存在的意义就是为了被子类重写,以便子类自己来定制比较规则

对象进行内容比较的时候建议使用Objects提供的equals方法,比较结果是一样的,但更安全!!

    System.out.println(s1==null);
    System.out.println(Objects.isNull(s1)); //二者功能完全一样,只是后者更帅一点

 

 StringBuilder常用方法 

Math类: 包含执行基本数字运算的方法,Math类没有提供公开的构造器,该类的成员都是静态的,通过类名就能直接访问

Math类的常用调用方法:

 

System类:System的功能是通用的,都是直接用类名调用即可,所以System不能被实例化,即不能创建对象,成员都是静态的

System类的常用方法

BigDecimal作用：用于解决浮点型运算精度失真的问题

 使用步骤：创建对象BigDecimal封装浮点型数据（最好的方式是调用方法）

public static BigDecimal valueOf(double val): 包装浮点数成为BigDecimal对象

BigDecimal常用API

Date类的概述: Date类的对象在Java中代表的是当前所在系统的此刻日期时间

      SimpleDateFormat 解析字符串时间成为日期对象 字符串时间的解析格式：

//1.把字符串时间拿到程序中来
       String dateStr = "2021年08月06日 11:11:11";
 //2.把字符串时间解析成日期对象(重点):形式必须与被解析时间的形式完全一样,否则运行时解析报错!
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
       Date d = sdf.parse(dateStr); 
 //3.往后走2天 14小时 49分 06秒
       long time = d.getTime() + (2L * 24 * 60 * 60 + 14 * 60 * 60 + 49 * 60 + 6) * 1000;
 //4.格式化这个时间毫秒值就是结果
       System.out.println(sdf.format(time));

检验该时间是否在一时间段内

  String startTime = "2021-11-11 00:00:00";
        String endTime = "2021-11-11 00:10:00";
        String xiaoJia = "2021-11-11 00:03:47"; 
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf.parse(startTime);
        Date d2 = sdf.parse(endTime);
        Date d3 = sdf.parse(xiaoJia);
        if(d3.after(d1)&& d3.before(d2))

Calendar概述

● Calendar代表了系统此刻日期对应的日历对象

● Calendar是一个抽象类，不能直接创建对象

Calendar常用方法

Calendar得到日历对象的方式: public static Calendar getInstance();  获取当前日历对象 

LocalDateTime的转换API

 (了解API)

 

包装类

正则表达式的匹配规则：

  

Lambda 

 

 

 注：it.hasNext是询问集合当前位置是否有元素，it.next是取出当前位置的元素并且再指向后面一个元素

增强for的快捷键：  集合名称.for+enter 

常见数据结构

栈数据结构的执行特点：后进先出，先进后出

队列数据结构的执行特点：先进先出，后进后出        

注：数组根据索引查询数据快，链表增删数据快 

 

   重点       

规则：小的存右边，大的存左边，一样的不存

 注：红黑树增删改查的性能都很好！

 注意：ArrayList底层是基于数组实现的，根据查询元素快，增删相对较慢，但实际开发并不慢

            LinkedList底层基于双链表实现的，查询元素慢，增删首尾元素是非常快的

集合的并发修改异常问题：遍历

 

 

 

ｌｉｎｋ　ｏｖｅｒ： 

 Ａｌｌ　ｉｎ　ａｌｌ：