devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JavaSE基础笔记（全）_java se学习笔记

作者：空白诗007 | 2024-06-25 12:12:57

赞

踩

java se学习笔记

文章目录

JAVA语言的初识

JDK的下载及安装

官方下载路径

在这里插入图片描述

  1. 点击下载好的文件进行安装，尽量安装在固态硬盘中，一路下一步即可。

  2. 安装完成就配置环境变量

    新建CLASSPATH:

在这里插入图片描述

新建JAVA_HOME:

在这里插入图片描述

在path中加入：

在这里插入图片描述

  1. 环境变量配置完成，检查是否配置正确，启动命令窗口：win+R：cmd
    • 输入java、javac、java -version：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Okay！至此jdk就配置完成~

简单的DOS命令

1.打开cmd：

  1. win+r：输入cmd；

  2. 文件地址栏输入cmd：

    在这里插入图片描述

  3. 开始+系统+命令提示符：
    在这里插入图片描述

管理员运行：

在这里插入图片描述

2.常用的Dos命令

  1. 盘符切换：d:

在这里插入图片描述

  1. 查看当前目录下的所有的文件：dir

在这里插入图片描述

  1. 切换目录：cd /d 路径

    在这里插入图片描述

  2. 返回上一级：cd…

    在这里插入图片描述

  3. 清除屏幕：cls

    在这里插入图片描述

  4. 退出窗口：exit

  5. 查看本机ip：ipconfig

在这里插入图片描述

  1. ping命令：ping www.baidu.com

  2. 相关文件的操作：

    • md 创建文件夹
    • rd 移除文件夹
    • cd>a.txt 新建文件
    • del a.txt 删除文件

    文件的移除是不会移除至回收站中

在这里插入图片描述

JDK、JRE、JVM

JDK

  1. JDK是JRE的超集，JDK包含了JRE的所有开发，调试和监视应用程序的工具。当要开发Java应用程序时，需要安装JDK.
  2. javac、java、javadoc、jar

JRE

Java运行时环境(JRE)是一个软件包，它捆绑了libraries(jar)和JVM，以及用Java编写的应用程序的其他组件。

JVM

JVM(JAVA虚拟机)是运行Java字节码的虚拟机,通过编译.java文件为.class文件得到字节码文件 . .class文件包含JVM可以理解的字节码。

JDK、JRE、JVM三者之间的关系

在这里插入图片描述

JDK，JRE，JVM相关的面试题

  • Java中的类加载有几种类型

    三种，分别是：Bootstrap,extendsion,application

  • 类加载器是如何工作的

    类加载器扫描它们预定义的jar文件和类的位置。它们扫描路径中的所有类文件并寻找所需的类。如果发现类则加载，链接并初始化类文件。

  • JRE和JVM的不同

    JVM是运行时环境的规范，它执行Java应用程序。Hotspot JVM就是这种规范的一种实现。它加载类文件，使用interpreter和JIT Compiler将字节码转换成机器码并执行它。

  • interpreter和JIT compiler的不同

    interpreter逐行解释字节码并按顺序执行。这会导致性能低下。JIT compiler通过在块中分析代码并在这个过程添加优化，然后准备（编译）为更优化的机器码。

Java程序运行机制

  1. 使用编辑器或IDE(集成开发环境)编写Java源文件.即.java文件
  2. 程序必须编译为字节码文件，javac(Java编译器)编译源文件为.class文件.
  3. 类文件可在任何平台/操作系统上由JVM(Java虚拟机)执行
  4. JVM将字节码文件翻译为机器可以执行的机器码(0,1二进制)

在这里插入图片描述

编译型、解释型

  1. JAVA 语言是一种编译型-解释型语言，同时具备编译特性和解释特性。其实，确切的说 Java 就是解释型语言，其所谓的（预）编译过程只是将 .java 文件编程成平台无关的字节码 .class 文件（生成的代码是介于机器码和Java源代码之间的中介代码），并不是向 C 一样编译成可执行的机器语言。作为编译型语言，JAVA 程序要被统一编译成字节码文件——>文件后缀是 .class 。此种文件在 Java 中又称为类文件。Java 类文件不能在计算机上直接执行，它需要被 JVM（Java 的虚拟机平台，可视为解释器）翻译成本地的机器码后才能执行，而Java 虚拟机的翻译过程则是解释性的过程。Java 字节码文件首先被加载到计算机内存中，然后读出一条指令，翻译一条指令，执行一条指令，该过程被称为 Java 语言的解释执行。而在现实中，Java 开发工具 JDK 提供了两个很重要的命令来完成上面的编译和解释（翻译）过程。两个命令分别是java.exe 和 javac.exe，前者加载 Java 类文件，并逐步对字节码文件进行编译，而另一个命令则对应了 Java 语言的解释（javac.exe）过程。在次序上，Java 语言是要先进行编译的过程，接着解释执行。这样既保留了源代码的高抽象、可移植的特点，又已经完成了对源代码的大部分预编译工作，所以执行起来比“纯解释型”程序要快许多。

Java包括三大块SE、EE、ME

1.JavaSE

  1. Java标准版（一套类库：别人写好的一套类库，只不过这个类库是标准类库，走EE，或者走ME，这个SE一定是基础，先学。）

2.JavaEE（WEB方向，WEB系统。）

  1. Java企业版（也是一套类库：也是别人写好的一套类库，只不过这套类库可以帮助我们完成企业级项目的开发，专门为企业内部提供解决方案的一套（多套）类库。）
  2. 别人写好的，你用就行了，用它可以开发企业级项目。
  3. 可以开发web系统。 Java比较火爆的就是这个JavaEE方向。
  4. JavaEE实际上包括13种规范，其中Servlet就是JavaEE规范之一

3.JavaME

  1. Java微型版（还是一套类库，只不过这套类库帮助我们进行电子微型设备内核程序的开发）
  2. 机顶盒内核程序，吸尘器内核程序，电冰箱内核程序，电饭煲内核程序。。。。。

基础语法

注释

  1. 单行注释：//
  2. 多行注释：/* */
  3. 文档注释：/** */ (可以通过javadoc生成帮助文档)

javadoc生成jdk帮助文档

IDEA 的 JavaDoc 生成功能在菜单 Tools->Generate JavaDoc 项里面。

在这里插入图片描述

关键字

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。

abstractassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplementsimport
instanceofintinterfacelongnative
newpackageprivateprotectedpublic
returnstrictfpshortstaticsuper
switchsynchronizedthisthrowthrows
transienttryvoidvolatilewhile

数据类型

1.java是强类型语言

  1. 要求所有的变量严格符合规定，所有的变量都必须先定义后才能使用

2.Java的数据类型分为两大类

  1. 基本数据类型（8类）
  2. 引用数据类型（3类）

  • 位（bit）：计算机中最小的存储单位；

  • 字节（byte）：计算机中数据处理的基本单位，习惯使用B表示；

  • 单位转换：

    • 1B=8bit；
    • 1kb=1024b;
    • 1m=1024kb;
    • 1g=1024m;

  • 字符：指计算机中使用的字母、数字、字和符号

  • 电脑的32位和64位区别：

    • 32位的电脑只能使用4gb；
    • 64位电脑内存可以无限大；

3、常见的问题

  1. 银行业务的表示：

    不能使用浮点数，会有舍入误差，只能说接近，因为会有精度损失

  2. BigDecimal：数学工具类；

  3. a=97;A=65;

    • char c1=‘a’;System.out.println((int)c1);----->97;

变量、常量、作用域

1、变量

package com.simon.demo01;
public class Test01 {
    public static void main(String[] args) {
        //局部变量
        int a=100;
        //常量
        final int MAX_A=100;
        Test01 test01 = new Test01();
        System.out.println(test01.id);
        System.out.println(b);
        System.out.println(MAX_A);
        System.out.println(PI);
        System.out.println(a);
    }
    //实例变量
    int id;
    String name;
    int age;
    //类变量
    static int b;
    static final double PI=3.14;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

在这里插入图片描述

2、自增自减

package com.simon.demo01;
public class Test02 {
    public static void main(String[] args) {
        int a=3;
        System.out.println(a);
        int b=a++;//先赋值再+1
        System.out.println(a);//a=a+1
        System.out.println(b);
        int c=++a;//先+1，再赋值
        System.out.println(a);
        System.out.println(c);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

在这里插入图片描述

命名规范

1、项目名全部小写.
2、包名全部小写.
3、类名首字母大写,多个单词情况下使用驼峰命名规则.
4、变量名,方法名首字母小写,如果名称由多个单词组成,使用驼峰命名规则.
5、常量名全部大写.
6、所有命名规则必须遵循以下规则 :

  • 名称只能由字母、数字、下划线、$符号组成.
  • 不能以数字开头.
  • 名称不能使用Java中的关键字.
  • 尽量不使用中文及拼音命名.

包名命名方式

一般公司命名为com.公司名.项目名.模块名....;

1.indi : 个体项目,指个人发起,但非自己独自完成的项目,可公开或私有项目,copyright主要属于发起者.

  • 包名 :indi.发起者名.项目名.模块名..

2.pers : 个人项目,指个人发起,独自完成,可分享的项目,copyright主要属于个人.

  • 包名 : pers.个人名.项目名.模块名…

3.priv : 私有项目,指个人发起,独自完成,非公开的私人使用的项目,copyright属于个人.

  • 包名 : priv.个人名.项目名.模块名…

4.onem : 与indi相同，推荐使用indi.

运算符

算数运算符

操作符描述例子
+加法 - 相加运算符两侧的值A + B 等于 30
-减法 - 左操作数减去右操作数A – B 等于 -10
*乘法 - 相乘操作符两侧的值A * B等于200
/除法 - 左操作数除以右操作数B / A等于2
％取余 - 左操作数除以右操作数的余数B%A等于0
++自增: 操作数的值增加1B++ 或 ++B 等于 21
–自减: 操作数的值减少1B-- 或 --B 等于 19

赋值运算符

2 赋值运算符主要有两类：

一类是使用等号（=）赋值，它把一个表达式的值赋给一个变量或对象；

另一类是扩展的赋值运算符。

3 赋值运算符的格式

variableName = expression;

这里，variableName为变量名，expression为表达式。其功能是将等号 右边表达式的值赋给左边的变量。

例如：

int x = 10;

int y = x + 20;

关系运算符

运算符描述例子
==检查如果两个操作数的值是否相等，如果相等则条件为真。（A == B）为假。
!=检查如果两个操作数的值是否相等，如果值不相等则条件为真。(A != B) 为真。
>检查左操作数的值是否大于右操作数的值，如果是那么条件为真。（A> B）为假。
<检查左操作数的值是否小于右操作数的值，如果是那么条件为真。（A <B）为真。
>=检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。（A> = B）为假。
<=检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。（A <= B）为真。

逻辑运算符

操作符描述例子
&&称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。（A && B）为假。
| |称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。（A | | B）为真。
！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。！（A && B）为真。

位运算符

操作符描述例子
＆如果相对应位都是1，则结果为1，否则为0（A＆B），得到12，即0000 1100
|如果相对应位都是0，则结果为0，否则为1（A | B）得到61，即 0011 1101
^如果相对应位值相同，则结果为0，否则为1（A ^ B）得到49，即 0011 0001
〜按位取反运算符翻转操作数的每一位，即0变成1，1变成0。（〜A）得到-61，即1100 0011
<<按位左移运算符。左操作数按位左移右操作数指定的位数。左x2A << 2得到240，即 1111 0000
>>按位右移运算符。左操作数按位右移右操作数指定的位数。右/2A >> 2得到15即 1111
>>>按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。A>>>2得到15即0000 1111

条件运算符(三目运算符)

表达式：

variable x = (expression) ? value if true : value if false

int a = 10;
int b = 20;
//求最大值
int c = (a>b)? a:b;
System.out.println(c);//20

  • 1
  • 2
  • 3
  • 4
  • 5

扩展运算符

操作符描述例子
+ =加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数C + = A等价于C = C + A
- =减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数C - = A等价于C = C - A
* =乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数C * = A等价于C = C * A
/ =除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数C / = A等价于C = C / A
（％）=取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数C％= A等价于C = C％A
<< =左移位赋值运算符C << = 2等价于C = C << 2
>> =右移位赋值运算符C >> = 2等价于C = C >> 2
＆=按位与赋值运算符C＆= 2等价于C = C＆2
^ =按位异或赋值操作符C ^ = 2等价于C = C ^ 2
| =按位或赋值操作符C | = 2等价于C = C | 2

运算符的优先级

类别操作符关联性
后缀() [] . (点操作符)左到右
一元+ + - ！〜从右到左
乘性* /％左到右
加性+ -左到右
移位>> >>> <<左到右
关系>> = << =左到右
相等== !=左到右
按位与＆左到右
按位异或^左到右
按位或|左到右
逻辑与&&左到右
逻辑或| |左到右
条件？：从右到左
赋值= + = - = * = / =％= >> = << =＆= ^ = | =从右到左
逗号，左到右

流程控制

用户交互

import java.util.Scanner;

package com.simon.demo06;
import java.util.Scanner;
public class Test03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入两个整数：");
        int i1 = scanner.nextInt();
        int i2 = scanner.nextInt();
        int add = add(i1, i2);
        System.out.println(add);
        //关闭输入流
        scanner.close();
    }
    public static int add(int a, int b){
        return a+b;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

顺序结构

顺序结构：就是从头到尾依次执行每条语句的操作。

选择结构

  1. 选择结构：也称条件控制，是指根据表达式的值有选择的执行。

  2. 在java中，选择结构分为if-else语句和 switch 语句。

    1. if-else结构：
    //单选择结构
if(布尔表达式){
    语句或语句块
}else{
    语句或语句块
}
//多选择结构
if(布尔表达式){
    语句或语句块
}else if(布尔表达式){
    语句或语句块
}else{
    语句或语句块
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

注意：

1）if括号里表达式的值返回的必须是布尔类型

2）如果条件体内只有一条语句需要执行，那么if后面的大括号可以省略。建议不要省略！

3）如果出现有多个if一个else的情况，else子句归属于最内层的if语句。

​ 2. switch:

switch(表达式){
case 常量值1:
    语句块;
    break;
case 常量值2:
    语句块;
    break;
case 常量值3:
    语句块;
    break;
        ..
default:
    语句块;
    break;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

注意：

1）switch中表达式的返回值只能是int，byte，char，short，枚举，字符串；

2）case子句中的值必须是常量，且不能重复；

3）default可有可无;

4）break作为某一个case代码段的结束句，使其跳出程序。

循环结构

  1. 循环结构：也称回路控制，是根据循环初始条件和终结要求，执行循环体内的操作。

  2. 在java中，循环结构有三种，分别是while循环、do-while循环、for循环。

    • while循环：循环条件为true，执行代码块，一直到循环条件为false 则跳出循环。
    while(循环条件){
    代码块
}

    • 1
    • 2
    • 3
  • do-while循环：先执行代码块，再判断循环条件，循环条件为true，则继续执行代码块，否则跳出循环。
  • **注意：**do-while循环的特点是无论循环条件是否为true，都会先执行一遍代码块
do{
    代码块;
}while(循环条件);

  • 1
  • 2
  • 3
  • for循环：for循环可以用来重复执行某条语句，直到某个条件得到满足。
for(表达式1;表达式2;表达式3){
    代码块;
}

  • 1
  • 2
  • 3

break && continue&&return

  1. break语句：

    ​ break语句刚刚在switch中已经见过了，是用来终止case的。实际上，break出现在while，do-while，for循环中，用于强行退出当前循环。

  2. continue语句：

    ​ continue只能用于for，while，do-while循环语句中，用于让程序跳出本次循环，直接进入下次循环。

  3. return语句：

    • 结束方法；
    public void show(){
        System.out.println("show---");
        return;//结束方法
    }

    • 1
    • 2
    • 3
    • 4
  • 返回值
public static int add(int a, int b){
        return a+b;//返回值
    }

  • 1
  • 2
  • 3

方法

何谓方法

  1. java方法是语句的集合，他们在一起执行一个功能；可以反复调用，增加代码的复用性。
  2. public static void main(String[] args){}
  3. System.out.println();

方法的定义和调用

  1. [修饰符] 返回值类型 方法名（[参数类型 参数名]，[…]）{return 值}
public class Test03 {
    public static void main(String[] args) {
        test(3,5);//调用静态方法
        Test03 test03 = new Test03();
        System.out.println(test03.test01(1,2,3));//调用非静态方法
    }
    static void test(int a, int b){
        System.out.println(a+b);
        }
    int test01(int a,int b,int c){
        return a+b+c;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

方法的重载

  1. 方法名必须相同
  2. 参数列表必须不同（个数不同、参数类型不同、参数列表的顺序不同）
  3. 参数的返回值类型可以不同也可以相同
  4. 仅仅返回值类不同不足以构成方法的重载
public static void main(String[] args) {
        test(3,5);//调用静态方法
        Test03 test03 = new Test03();
        System.out.println(test03.test(1,2,3));//调用非静态方法
        System.out.println(test03.test(1.0,2.0));
    }
    static void test(int a, int b){
        System.out.println(a+b);
        }
    int test(int a,int b,int c){
        return a+b+c;
    }
    double test(double a,double b){
        return a+b;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

可变参数

  1. 类似于数组

  2. int test(int... a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"\t");
        }
        return 0;
    }
test03.test(1,2,3,4,5);//方法的调用
 
    输出结果：
     
    在这里插入图片描述
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

面向对象

类和对象的关系

  1. 类是抽象的数据类型，并不能代表某一个具体的事物；类是对象的一个模板。
  2. 对象是类的具体实例。

类和对象的创建

在这里插入图片描述

构造器

  1. 方法名和类名相同；
  2. 无参构造器是默认存在的；
  3. 如果自己定义了一个有参构造器，那么无参构造器必须显示定义；
public class Student {
    String name;
    int age;
    //alt+insert自动生成
    //无参构造器
    public Student() {
    }
    //有参构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    void study(){
        System.out.println(this.name+"\t"+this.age+"\t"+"在学习！");
    }
}
public class Application {
    public static void main(String[] args) {
        Student student1 = new Student("lscong",22);
        student1.study();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

在这里插入图片描述

封装

  1. 程序追求“高内聚、低耦合”，
  2. 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
  3. 低耦合：尽量暴露少量的方法给外部使用；
  4. 私有属性----定义set、get方法
public class Person {
    private String name;
    private int age;
    private int score;
    public Person() {
    }
//alt+insert选择getter、setter
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
   public int getScore() {
        return score;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setScore(int score) {
        this.score = score;
    }
}
Person person = new Person();
person.setName("李思聪");
System.out.println(person.getName());

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

继承

  1. 关键字：extends；
  2. java中只有单继承，没有多继承；
  3. 子类拥有父类所有的东西，但是私有的东西是不能被继承的；
  4. Object是所有类的父类，直接继承Object

在这里插入图片描述

  1. super关键字：调用父类的属性及方法

    public Student() {
        //super();----默认调用父类的构造方法，且super必须放在第一行
        System.out.println("Student无参构造器!");
    }

    • 1
    • 2
    • 3
    • 4

在这里插入图片描述

  1. 重写：

    alt+insert

    • 需要有继承关系，子类重写父类
    • 方法名必须相同，方法体不同
    • 参数列表必须相同
    • 修饰符可以扩大：public>protected>default>private
    • 抛出的异常：可以缩小，但是不能扩大
    • 子类重写了父类，那么对象调用的就是执行重写的方法

    为什么重写：

    • 父类的功能，子类不一定需要，或者不一定能够满足

多态

  1. 可以实现动态编译

    //一个对象的实际类型是确定的
new Student();
new Person();
//可以指向的引用类型就是不确定的，父类的引用指向子类
Student s1=new Student();
//父类不能调用子类独有的方法
Person s2=new Student();
Object s3=new Student();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
  • 能不能调用，主要看左边类是否存在该方法
  • 如果子类重写了父类的方法，那么都是执行子类重写的方法
  • 可以强制转换，高->低

  • 注意事项：

    • 多态是方法的多态，属性是没有多态的

    • 存在的条件：继承关系，方法需要重写，父类的引用指向子类对象（Father f1=new Son（）；）

      不存在多态：

      • static 静态的方法 属于类，不属于实例
      • final 常量
      • private 私有的

instanceof

  1. 判断两边类型是否存在父子关系

  2. X instanceof Y

    Student s1=new Student();
Person s2=new Student();
Object s3=new Student();
//Object>Person>Student
//Object>Person>Teacher
//Object>String
s3 instanceof Student//true
s3 instanceof Person//true
s3 instanceof Object//true
s3 instanceof String//false
s3 instanceof Teacher//false
s1 instanceof Student//true
s1 instanceof Person//true
s1 instanceof Object//true
s1 instanceof String//编译错误
s1 instanceof Teacher//编译错误    
s2 instanceof Student//true
s2 instanceof Person//true
s2 instanceof Object//true
s2 instanceof String//编译错误
s2 instanceof Teacher//false

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

抽象类

  1. abstract关键字
  2. 是一种约束，抽象方法，只有方法没有具体的实现
  3. 只能靠子类去实现方法
  4. 抽象类中可以存在非抽象类方法，但是非抽象类不能写抽象方法
  5. 子类继承抽象类，必须对其抽象方法进行重写

问题：

  1. 抽象类存在构造器吗？

    • 抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。

      abstract class Base{
    int a=7;
    public Base(){
    	a=8;
    }
    public Base(int i){
    	a=i;
    }
}
public class Demo01 extends Base {
	public Demo01(){
		super();
	}
	public Demo01(int i){
		super(i);
	}
	public static void main(String[] args) {
		Demo01 demo=new Demo01();
	    System.out.println(demo.a);
	    Demo01 demo1=new Demo01(9);
	    System.out.println(demo1.a);
	}
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23

  2. 存在的意义？

    • 因为抽象类不能实例化对象，所以必须要有子类实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护。
    • 当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。

接口

  1. implements：继承关键字

  2. interface：修饰符

  3. [public abstract] void run();

  4. 接口中定义的变量均为常量：[public abstract final ] AGE=100；

  5. 接口可以实现多继承

  6. 只有规范，自己无法写方法

  7. 以后均在面向接口编程

  8. 子类继承接口，子类必须对其方法进行重写

内部类

成员内部类

public class Outer{
    private String name;
    private int age;
    public void outer(){
     	System.out.println("outer!");   
    }
 		public class Inner{
            public void inner(){
             	   System.out.println("inner!");   
            }
        }
}
//new
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.inner();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

静态内部类

public class Outer{
    private String name;
    private int age;
    public void outer(){
     	System.out.println("outer!");   
    }
 		public static class Inner{
            public void inner(){
             	   System.out.println("inner!");   
            }
        }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

局部内部类

public class Outer{
    private String name;
    private int age;
    public void outer(){
        public class Inner{
            private int score;
            void run(){
             	   System.out.println("run!");  
            }
        }
     	System.out.println("outer!");   
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

匿名内部类

public class Outer{
    private String name;
    private int age;
    public void outer(){
     	System.out.println("outer!");   
    }
}
class Outer1{
            public void outer1(){
             	   System.out.println("outer1!");   
            }
        }
//new,没有名字的初始化，不用将实例保存在变量中
new Outer1().outer();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

常用类

枚举类

如何自定义枚举类

  1. 类的对象只有有限个，确定的

  2. 当需要定义一组常量时，强烈建议使用枚举类

package com.simon.demo06;
//jdk5.0之前自定义枚举类
public class Test01 {
   public static void main(String[] args) {
       Season summer = Season.SUMMER;
       System.out.println(summer);
 }
}
//自定义枚举类
class Season {
   //声明Season对象的属性，private final修饰
   private final String seasonName;
   private final String desc;
   //类的构造器，并给类的对象赋值
   private Season(String seasonName, String desc) {
       this.seasonName = seasonName;
       this.desc = desc;
   }
   //提供当前枚举类的多个对象
   public static final Season SPRING = new Season("春天","春暖花开");
   public static final Season SUMMER = new Season("夏天","夏日炎炎");
   public static final Season AUTUMN = new Season("秋天","秋高气爽");
   public static final Season WINTER = new Season("冬天","凉风飕飕");
   //其他诉求，获取枚举类的对象属性
   public String getSeasonName() {
       return seasonName;
   }
   public String getDesc() {
       return desc;
   }
   //提供toString（）
   @Override
   public String toString() {
       return "Season{" +
               "seasonName='" + seasonName + '\'' +
               ", desc='" + desc + '\'' +
               '}';
   }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

如何使用enum定义枚举类

package com.simon.demo06;
//jdk5.0之后enum定义枚举类
public class Test01 {
    public static void main(String[] args) {
        Season summer = Season.SUMMER;
        System.out.println(summer);//SUMMER
        System.out.println(Season.class.getSuperclass());//class java.lang.Enum
    }
}
//自定义枚举类
enum  Season {
    //提供当前枚举类的多个对象;多个对象之间使用逗号隔开，最后使用分号
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","凉风飕飕");
    //声明Season对象的属性，private final修饰
    private final String desc;
    private final String seasonName;
    //类的构造器，并给类的对象赋值;
    private Season(String seasonName, String desc) {
        this.seasonName = seasonName;
        this.desc = desc;
    }
    //其他诉求，获取枚举类的对象属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getDesc() {
        return desc;
    }
    /*//提供toString（）
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }*/
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

Enum类的主要方法

  1. values（）

  2. valueOf（）

  3. toString（）

    //valuesOf(String name),根据提供的参数找到name
Season winter = Season.valueOf("WINTER");
System.out.println(winter);//WINTER
//values:枚举类中存在哪些对象
Season[] values = Season.values();
for(Season s:values){
    System.out.println(s);//SPRING、SUMMER、AUTUMN、WINTER
}
//toString(),返回对象名
System.out.println(summer.toString());//SUMMER
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

实现接口的枚举类

package com.simon.demo06;
//jdk5.0之前自定义枚举类
import javax.swing.*;
public class Test01 {
    public static void main(String[] args) {
        Season summer = Season.SUMMER;
        //toString(),返回对象名
        System.out.println(summer.toString());//SUMMER
       //实现接口，使得每个对象可以调用不同的show（）
        Season autumn = Season.AUTUMN;
        autumn.show();//秋天在哪里
        System.out.println(Season.class.getSuperclass());//class java.lang.Enum
        //values:枚举类中存在哪些对象
        Season[] values = Season.values();
        for(Season s:values){
            System.out.println(s);//SPRING、SUMMER、AUTUMN、WINTER
        }
        //valuesOf(String name),根据提供的参数找到name
        Season winter = Season.valueOf("WINTER");
        System.out.println(winter);//WINTER
    }
}
interface Season1{
    void show();
}
//自定义枚举类
enum  Season implements Season1{
    //提供当前枚举类的多个对象;多个对象之间使用逗号隔开，最后使用分号
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("夏天在哪里");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("秋天在哪里");
        }
    },
    WINTER("冬天","凉风飕飕"){
        @Override
        public void show() {
            System.out.println("冬天在哪里");
        }
    };
    //声明Season对象的属性，private final修饰
    private final String desc;
    private final String seasonName;
    //类的构造器，并给类的对象赋值;
    private Season(String seasonName, String desc) {
        this.seasonName = seasonName;
        this.desc = desc;
    }
    //其他诉求，获取枚举类的对象属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getDesc() {
        return desc;
    }
    /*//提供toString（）
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }*/
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

包装（Wrapper）类

  1. 八种基本数据类型定义相应的包装类：

    基本数据类型包装类
    byteByte
    shortShort
    intInteger
    longLong
    floatFloat
    doubleDouble
    booleanBoolean
    charCharacter

  2. 基本数据类型、包装类、String之间的相互转换

    int nums = 10;
Integer num = new Integer(nums);//装箱
System.out.println(num);
int i = num.intValue();//拆箱
System.out.println(i);
 
    • 1
    • 2
    • 3
    • 4
    • 5

  3. 与String之间的转换：

 //方式一
String str1 = nums + "";
//方式二
String str = String.valueOf(nums);
//无论是基本数据类型还是包装类均可调用valueOf（）
String str2 = String.valueOf(num);
//String转换为基本数据类型
//没有关系的类是无法进行强转的
int i1 = Integer.parseInt(str);
//Integer i2 = new Integer(Integer.parseInt(str));
Integer i3 = Integer.parseInt(str);
String str3 = "true";
boolean bl = Boolean.parseBoolean(str3);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  1. 自动装箱和拆箱(新特性)：
Integer in1 = nums;//自动装箱        
int in2 = in1;//自动拆箱

  • 1
  • 2

String类

String类及常用方法

  1. String的特性：
    1. String类代表字符串；
    2. String是个final类，是个不可变的字符序列;
    3. 字符串是常量，使用“”来表示，他们的值创建了之后是不能被改变的；
    4. String对象的字符内容是存储在一个**字符数组value[]**中的;
public class Test01 {
    public static void main(String[] args) {
            String s1="abc";
            String s2="abc";
        System.out.println(s1 == s2);//true
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

在String常量池中，如果定义的String常量是相同的那么就是使用的同一个对象，如果不是相同的常量那么就会新建一个对象。

public static void test(){
        String str2 = new String("hello");
        String str1 = new String("hello");
        System.out.println(str1==str2);//false
    }

  • 1
  • 2
  • 3
  • 4
  • 5

此时创建的是两个不同的对象，所有返回false

  • 问题：String str1 = new String(“hello”);在内存中创建了几个对象？

    答：2个，一个是在对空间中new的一个对象，另一个是在常量池中的数据"hello"

  1. 字符串的拼接

    public static void test2(){
        String s1="abc";
        String s2="def";
        String s3=s1+s2;
        String s4="abc"+"def";
        String s5=s1+"def";
        String s6="abc"+s2;
        String s7="abcdef";
		System.out.println(s4 == s7);//true
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        System.out.println(s3 == s7);//false
        System.out.println(s3 == s4);//false
    	String s8=s5.intern();
        System.out.println(s7 == s8);//true
    }
 
    有变量参与的字符串拼接都是在对空间中new创建的对象，那么对象就是不同的；如果是字面量拼接的都是在常量池中创建的，如果结果是相同的，那么对象就是相同的；如果拼接调用了intern方法，那么该字符串对象就在常量池中，此时对象就是相他同的。
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

  2. String的常用方法

    1. public static void test3(){
        String s1="helloworld";
        System.out.println(s1.length());//长度
        System.out.println(s1.charAt(0));//字符索引
        System.out.println(s1.charAt(2));
        System.out.println(s1.charAt(4));
        System.out.println(s1.isEmpty());//是否为空
        String s2 = s1.toUpperCase();//大写
        System.out.println(s2);
        String s4="  helloWorld!   ";
        String s3 = s4.trim();//去除前后空格
        System.out.println(s3);
        System.out.println(s1.equals(s4));//比较字符串的值是否相同
        String s5="HelloWorld";
        System.out.println(s1.equalsIgnoreCase(s5));//忽略大小写的比较
        String s6="abc";
        String s7="abe";
        System.out.println(s6.compareTo(s7));//比较大小，依次比较
        System.out.println(s1.substring(5));//截取字符串
        System.out.println(s6.concat("def"));//连接字符串，等价于“abc”+“def”
    }
 
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21

  3. String 与基本数据类型之间的转换

    public static void test4(){
        String s1="123";
        int s2 = Integer.parseInt(s1);
        System.out.println(s2);
        String s3 = String.valueOf(s2);
        System.out.println(s3);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

  4. String类型与char型数组之间的转化

    public static void test5(){
        String s1="helloworld";
        char[] chars = s1.toCharArray();
        for (int i = 0; i <chars.length ; i++) {
            System.out.print(chars[i]);
        }   
    		char[] c1={'h','e','l','l','o'};
        	String s2 = new String(c1);
       		System.out.println(s2);
    }
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

StringBuffer及StringBuilder

  1. String、StringBuffer、StringBuilder区别

  • String：不可变字符串序列；使用char[]存储

  • StringBuffer：可变的字符串序列；线程安全的效率偏低；使用char[]存储

  • StringBuilder：可变的字符串序列；线程不安全的效率高；使用char[]存储

  1. 常用方法

     public static void test6(){
        StringBuffer stringBuffer = new StringBuffer("abc");//char[] value=new char[16]
        System.out.println(stringBuffer.length());//0
        stringBuffer.append('d').append('e');//添加，可以反复调用append（）abcde
        System.out.println(stringBuffer.delete(0, 1));//删除bcd
        System.out.println(stringBuffer.replace(0, 1, "hello"));//替换hellocde
        stringBuffer.insert(2,"false");//插入hefalsellocde
        System.out.println(stringBuffer.reverse());//翻转edcolleslafeh
        System.out.println(stringBuffer.indexOf("l"));//字符出现的次数3
        stringBuffer.substring(2);//截取字符串olleslafeh
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

主要关注增删改查

  • String、StringBuffer、StringBuilder执行效率

    String<StringBuffer<StringBuilder;String效率是极低的，在没有线程的时候就是用StringBuilder

  • File类

    File类的使用

    1. 实例化

      • import java.io.File;
      • File file = new File("hello.txt");//相对于该项目的路径下
      • File file1 = new File("G:\\idea\\java\\java01\\src\\com\\simon\\demo03\\hello.txt");//绝对路径
      • 相对路径：相较于某个路径下，指明的路径；
      • 绝对路径：包含盘符，一个完整的路径；

    2. File类的常用方法

      System.out.println(file.getName());//hello.txt
System.out.println(file.getAbsolutePath());//G:\idea\java\hello.txt
System.out.println(file.getParent());//null
System.out.println(file.getPath());//hello.txt
System.out.println(file.length());//0 文件的字节长度
System.out.println(file.lastModified());//0 最近一次修改时，时间戳！

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    1. 创建文件或文件夹

      //创建文件或文件夹
        boolean newFile=false;
        try {
            newFile = file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            System.out.println(newFile);
        }
        //删除文件或文件夹
        boolean delete1 = file1.delete();
        System.out.println(delete1);
        boolean delete = file.delete();
        System.out.println(delete);
        //创建文件夹
        //mkdir 只能使用相对路径创建，此方法在上级目录存在的情况下才可以创建
        //mkdirs，在上级目录不存在的情况下也可以创建，此时就一并创建了
        boolean mkdir = file1.mkdir();
        System.out.println(mkdir);
 
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

    时间日期类

    Date

    1. import java.util.Date;
    2. java.sql.Date—数据库中的Date
    3. 两个构造器的使用
    public static void test2(){
   		//构造器一、空参构造器
        Date d1 = new Date();//import java.util.Date;
        //构造器二
        Date date = new Date(2020, 1, 1);//自己定义，但是这个构造器已经过时了
        Date date1 = new Date(1601802431564L);//Sun Oct 04 17:07:11 CST 2020
     	/*@Deprecated
    	public Date(int year, int month, int date) {
        this(year, month, date, 0, 0, 0);*/    
   	//java.sql.Date
    	java.sql.Date date2 = new java.sql.Date(1601802431564L);
        System.out.println(date2.toString());//2020-10-04
    }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1. 两个方法的使用

      //方法一
System.out.println(d1.toString());//Sun Oct 04 17:05:05 CST 2020
//方法二
System.out.println(d1.getTime());//1601802431564，时间戳

      • 1
      • 2
      • 3
      • 4

    Calendar

    1. import java.util.Calendar;

    2. 可变性

    3. 不能直接new Calendar（）；因为该类是抽象类

      1. 可以new 其子类

        Calendar c = new GregorianCalendar();

      2. 还可以调用其静态方法，进行new

        Calendar instance = Calendar.getInstance();

    4. 常用方法

      1. get()

        int i = c.get(Calendar.DAY_OF_MONTH);

      2. set()

        c.set(Calendar.DAY_OF_MONTH,22);

      3. add()

        c.add(Calendar.DAY_OF_MONTH,3);

      4. getTime()

        Date time = c.getTime();

      5. setTime()

        c.setTime(date);

    SimpleDateFormat

    1. import java.text.SimpleDateFormat;

    2. SimpleDateFormat实例化

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat();//默认的构造器

    • 1

    1. 两个操作

      1. 格式化：日期————>字符串
      Date date = new Date();
System.out.println(date.toString());//Sun Oct 04 17:30:31 CST 2020
//默认格式化
String format = simpleDateFormat.format(date);
System.out.println(format);//20-10-4 下午5:30
//自己定义的格式化
//格式化日期 yyyy-MM-dd HH:mm:ss
//带参的构造器
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format1 = simpleDateFormat1.format(date);
System.out.println(format1);//2020-10-04 17:39:53
  
   
   
      1.  
        解析：格式化的逆过程；字符串—>日期
         
        String str="20-10-4 下午5:30";
Date parse = null;
try {
    parse = simpleDateFormat.parse(str);
} catch (ParseException e) {
    e.printStackTrace();
}
System.out.println(parse);//Sun Oct 04 17:30:00 CST 2020

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
       
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    JDK8之后的时间日期类

    1. LocalDate、LocalDateTime、LocalTime

    2. 实例化：

      public static void test5() {
        //实例化
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
        System.out.println(localDate);
        System.out.println(localTime);
    }
 
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    3. 不可变性

    4. 常用方法

      System.out.println(localDateTime.getDayOfMonth());//4
System.out.println(localDateTime.getDayOfWeek());//SUNDAY
System.out.println(localDateTime.getDayOfYear());//278
System.out.println(localDateTime.getMonth());//OCTOBER
//操作,体现不可变性
LocalDateTime localDateTime1 = localDateTime.withDayOfMonth(22);
System.out.println(localDateTime);//2020-10-04T19:57:27.576
System.out.println(localDateTime1);//2020-10-22T19:57:27.576
//增加天数
LocalDateTime localDateTime2 = localDateTime.plusDays(3);
System.out.println(localDateTime2);//2020-10-07T19:57:27.576
 
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    Instant

    1. 时间线上的一个瞬时点
    public static void test6() {
        //需要考虑时区，获取本初子午线对应的标准时间
        Instant instant =Instant.now();
        System.out.println(instant);//2020-10-04T12:02:45.416Z
        //根据时区去添加偏移量，+8
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2020-10-04T20:05:48.240+08:00
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    DateTimeFormatter

    1. 格式化日期
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
String format = dateTimeFormatter.format(LocalDateTime.now());
System.out.println(format);//2020/10/04 20:15:58

    • 1
    • 2
    • 3

    System类

    public static void test1(){
        long l = System.currentTimeMillis();//时间戳
        System.out.println(l);//1601801988015自1970.1.1 00:00:00开始到现在的时间差ms
     	String s = System.getProperty("java.version");
        System.out.println(s);//1.8.0_202
        String s1 = System.getProperty("java.home");
        System.out.println(s1);//C:\Program Files\Java\jdk1.8.0_202\jre
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    Math类

    public static void test01(){
        int i = Math.abs(-1);//绝对值
        double v = Math.sqrt(16);//平方根
        double v1 = Math.pow(3, 3);//3*3*3
        double v2 = Math.log(27);//自然对数
        double v3 = Math.exp(2);//e为底的指数
        double v4 = Math.random();//0-1随机数
        System.out.println(i);//1
        System.out.println(v);//4.0
        System.out.println(v1);//27.0
        System.out.println(v2);//3.295836866004329
        System.out.println(v3);//7.38905609893065
        System.out.println(v4);//0.41071285585678285
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    BigInteger及BigDecimal

    一般的float和double在进行商业计算的时候会有精度的损失，所有一般不使用浮点数，因此就出现BigDecimal类来进行高精度的计算

    import java.math.BigDecimal;

    public static void test02(){
        BigDecimal bigDecimal = new BigDecimal(1635.16411);
        BigDecimal bigDecimal1 = new BigDecimal(515);
        //ROUND_CEILING四舍五入
    System.out.println(bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING));//3.175075941747572693043587349572227996529885
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    比较器

    1. 由于对象只能使用==或者！=，不能使用>或者<；所以需要比较对象的大小，就有了以下两个比较类；

    2. 像String和包装类就实现了Comparable接口，重写了compareTo（）方法，给出了比较两个对象大小的方式；

    3. 对于自定义类，如果需要进行排序，那么就需要自己实现Comparable接口和重写compareTo（）。

      指明compareTo（obj）按照什么方式排序。

    Comparable

    Comparator

    集合

    Collection

    1. Collection类的常用方法

      public static void test03(){
       Collection<Object> objects = new ArrayList<>();
        //add()
        objects.add("123");
        objects.add(123);
        objects.add("aa");
        objects.add("bb");
        objects.add(new Date());
        System.out.println(objects.size());//5
        System.out.println(objects);//[123, 123, aa, bb, Sun Oct 04 21:31:28 CST 2020]
        System.out.println(objects.isEmpty());//false
        System.out.println(objects.contains("123"));//true
    	System.out.println(objects.remove(123));//true
    	System.out.println(objects.hashCode());//1250521029
    	Object[] objects1 = objects.toArray();//集合转换为数组
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i <objects1.length ; i++) {
            if(i<objects1.length-1){
                stringBuilder.append(objects1[i]+",");
            }else{
                stringBuilder.append(objects1[i]);
            }
        }
        stringBuilder.append("]");
        System.out.println(stringBuilder);//[123,aa,bb,Sun Oct 04 21:47:25 CST 2020]
    }
    }
 
      contains是比较内容，而不是比较的是对象。
       
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28

    2. Iterator迭代器

      • 用于变量容器中的元素
      //初始化
Iterator<Object> iterator = objects.iterator();
//遍历元素
//方式一
        for (int i = 0; i <objects.size() ; i++) {
            System.out.print(iterator.next()+"\t");//123	aa	bb	Sun Oct 04 21:59:40 CST 2020
        }
        //方式二
        while (iterator.hasNext()){
            System.out.print(iterator.next()+"\t");//123	aa	bb	Sun Oct 04 21:59:40 CST 2020
        }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    3. for-each（增强for循环）遍历集合或者数组

       for(Object obj:objects){
            System.out.print(obj+"\t");//123	aa	bb	Sun Oct 04 22:04:41 CST 2020
        }
 
      • 1
      • 2
      • 3

    List

    List接口是Collection的子接口，存储有序的，可重复的数据。

    ArrayList、LinkedList、Vector均是List接口的实现类

    但是ArrayList是List接口的主要实现类，Vector是最老旧的，基本上是不用的

    1. 三者之间的区别：

      1. ArrayList：线程是不安全的，但是效率高
      2. LinkedList：对于频繁插入和删除操作，效率比ArrayList高
      3. Vector：线程是安全的，但是效率极低。

    2. 相同点：三者均实现List接口，存储数据的特点：存储有序可重复的数据。

    3. ArrayList常用方法：

      public static void test04(){
        List<Object> objects = new ArrayList<>();
        List<Object> objects1 = new LinkedList<>();
        List<Object> objects2 = new Vector<>();
        //添加数据
        objects.add(1);
        objects.add(2);
        objects.add(3);
        objects.add(4);
        System.out.println(objects.get(2));//3 获取索引2处的数据
        System.out.println(objects.set(2, 5));//3 修改数据
        System.out.println(objects);//[1, 2, 5, 4]
        System.out.println(objects.remove(3));//4 移除索引为3处的数据
        System.out.println(objects.indexOf(1));//0 数据第一次出现的位置
        //遍历
        Iterator<Object> iterator = objects.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next());//125
        }
    }
 
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20

    Set

    Set是Collection的另一个子接口，是存储无序的，不可重复的数据

    Set的三个主要实现类：HashSet、LinkedHashSet、TreeSet

    1. 三者之间的区别：

      1. HashSet：作为Set的主要实现类，线程不安全的，可以存储null值
      2. LinkedHashSet：作为HashSet的子类，遍历其内部数据时可以按照添加的顺遍历
      3. TreeSet：存储数据必须是同一个类new的数据，可以根据添加对象的属性进行排序

    2. HashSet常用方法：

      全是Collection中存在的方法；

       HashSet<Object> objects = new HashSet<>();
        //添加数据
        objects.add(1);
        objects.add(3);
        objects.add;
        
      • 1
      • 2
      • 3
      • 4
      • 5

    原文链接：

    https://blog.csdn.net/weixin_45826188/article/details/108995282 

    • 1

    ————————————————
    版权声明：本文为CSDN博主「Sicong Lee」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/756148
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号