Java基础知识

• • 取值范围

• 8.输入流

• • 1.常用的System类（位于System.lang包）

• 2.InputStream类：

• 3. PrintStream类的常用方法

• 4.java.util.Scanner类

• • Scanner类的常用构造方法

• Scanner类的常用方法

• 5.FileInputStream类

• 6.FileOutputStream类

• 7.FileDescriptor类

• 9.输入输出缓冲流

• • 9.1 字节输入输出缓冲流
• • 1.BufferedInputStream

• 2.BufferedOutputStream

• 9.2 字符输入输出缓冲流

• • 1.BufferedReader

• 2.BufferedWriter

• 10.File文件类

• 11.lambda表达式

• 字符串常用方法

• • 2.字符串常用的构造方法

• 字符串常用方法

• 易错点

• 内部类

• • 普通成员内部类

• 方法内部类

• 静态内部类

• • 匿名内部类

• 使用成员内部类实现接口

• 枚举类

• • 使用enum定义枚举类
• • 枚举类的主要方法

• 反射

• 随机数

• • new Random()

• Math.random()

• currentTimeMillis()

• 时间戳获取

• 多线程

• • 进程和线程

• 扩展

• 线程的使用

• • 线程状态

• 线程休眠的另外一种方式

• StringBuffer类

• String类

• 日期类

• • Calendar类

• File类

• 异常

• IO流

• • 字节流

• 字符流

• • InputStreamReader和OutputStreamWriter类

1.子类继承父类

---

子类的每个对象都是父类的对象，这是继承的”即是“性质。反之，父类对象不一定是它的子类对象。

1.1 父类构造方法的调用

当创建子类时，回优先调用父类的无参构造方法。如果父类此时显示定义的构造方法没有无参构造方法，那么回报错。这时就需要在子类的构造方法的第一行用一个super()调用特定的父类的构造方法。如下：

package com;

class Parent{

private String name;

private int age;

public Parent(String name,int age){

this.name=name;

this.age=age;

System.out.println(“父类—”+“name=”+name+“—age=”+age);

}

}

public class InheritClass extends Parent{

private int count;

public InheritClass(int count){

super(“二狗子”,15);

this.count=count;

System.out.println(“子类的count=”+count);

}

public static void main(String[] args) {

InheritClass inheritClass=new InheritClass(10);

}

}

1.2 和super()很像的this()

1.共同点：他们都可以用来调用构造方法且他们都必须防止构造器的首部（即第一行的位置）

2.区别：super()用来调用父类的。this()用来调用同一个类中的构造方法。 具体如下：

public class InheritClass{

private int count;

private String size;

public InheritClass(){

this(“42码”);

}

public InheritClass(int count){

this.count=count;

System.out.println(“子类的count=”+count);

}

public InheritClass(String size){

this.size=size;

System.out.println(“子类的size=”+size);

}

public static void main(String[] args) {

InheritClass inheritClass=new InheritClass();

}

}

1.3 子类访问父类的成员

通过super.父类成员即可访问

1.4 父类对象访问子类成员

可以通过父类对象引用子类对象即可访问子类成员，如下：

person p=new son();

p.show(); 这时访问的即是子类的方法show()

1.5 子类对所继承父类的访问权限

1.对于成员变量的访问：

凡是父类中的final修饰的，或者普通的变量在父类的构造方法发中经过初始化的，都是可以获取父类中初始化的值的。对于默认构造方法初始化的成员变量，子类继承的改变量的值=0，（对于整型int这些）

2.重载和覆盖

---

1.覆盖定义：

在子类中定义的名称、参数个数与类型均与父类中完全相同的方法。用以重写父类中同名方法的功能。

2.重载定义：

是指同一个类内具有相同名称的多个方法，且这多个同名方法如果参数不同，或者参数个数相同（但类型不同），则这些同名方法就具有不同的功能。这就叫重载。

注意：

如果两个方法只有返回值类型不同，则不叫重载，编译器回报错，如下：

3.Object类常用的方法

---

1.public boolean equals(Object obj):判断2个变量是否指向同一个对象

2.public String toString():将调用该方法的对象转换为字符串。

3.public final Class getClass()：返回运行时对象所属的类。

4.protected Object clone():返回调用该方法对象的一个父本。

3.1 对象运算符instanceof

instanceof作用：用来测试一个指定对象是否是指定类或它的子类的实例。如下：

// 即测试obj是否为Student的实例或者是Student子类的实例。

if(obj instanceof Student){

…

}

4.native

---

native主要用于方法上

1、一个native方法就是一个Java调用非Java代码的接口。一个native方法是指该方法的实现由非Java语言实现，比如用C或C++实现。

2、在定义一个native方法时，并不提供实现体（比较像定义一个Java Interface），因为其实现体是由非Java语言在外面实现的

主要是因为JAVA无法对操作系统底层进行操作，但是可以通过jni(java native interface)调用其他语言来实现底层的访问。

5.抽象类

---

1.抽象类中的方法：必须用abstract关键字修饰。

2.其中的成员包括：

1.抽象方法

2.普通方法

3.成员变量

注意：

1.abstract 不能与priate、static、final 或native修饰同一种方法。

2.抽象类中不一定包含抽象方法。但包含抽象方法的类一定要声明为抽象类。

3.抽象类可以包含构造方法，但不能声明为抽象的。

6. 接口

---

1.其中的数据成员都必须是静态的且必须初始化。即数据成员必须是常量。

2.接口中可以声明抽象方法，静态方法、默认方法。

3.接口中的方法默认会用public abstract 来修饰。

4.若省略成员的修饰符，默认会使用public static final修饰。

注意：

1.用final修饰的变量不能被重新赋值（即不能更改）。

2.接口中的成员都是公共的（即public）

3.若定义接口中的抽象方法没有public修饰符，则子类实现其方法时，必须加上该public修饰符。

4.接口是一种特殊的抽象类。

6.1 接口的引用

任何实现该接口的类的实例都可以存储在该接口的类型变量中。即我们可以用这个接口的引用变量来访问实现该接口的类的对象。

如下：

假设：IShap：接口 circle：IShap的实现类

则：IShap ishap=new circle();

特别注意：

1.接口的引用型变量只能够接收实现了改接口的类的对象。其他的对象不行。只要这个类实现了这个接口，那么这个类的对象类型也即为接口的类型。相当于是同一个类型。

2.改接口的引用型变量只能调用实现了该接口的方法。实现该接口的类的其他方法不可以被改接口的引用型变量调用。

7.数据类型

---

Java中的数据类型分为2类，1类是基本数据类型，1类是引用数据类型。基本数据类型有8种。引用数据类型包括类、数组、接口。

整型：byte，short，int，long

浮点型：float，double

布尔型：boolean

字符型：char

取值范围

1.整型：

byte：8位

short：16

int：32

long：64

2.浮点型

float：32位

double：64位

3.布尔型

取值：true和false

4.字符型

编码方案：

1.java中采用的是用Unicode字符集编码方案。在内存中在2个字节。是16位无符号的整数。一共有65536个。字符的取值范围为0-65536个，表示其在Unicode字符集中的位置。

2.Unicode中的字符是用‘\u0000’到’\uFFFF’之间的16进制来表示的。前面的‘\u’表示是一个Unicode值。后面的表示是哪一个Unicode字符。

3.Unicode的前128个字符刚好是ASCII表。

4.要想得到一个字符在Unicode表示的位置必须强转（使用int）。

5.同样要获得一个整数所表示的Unicode字符。必须使用char进行强转。

数据类型转换

1.自动类型转换

需要满足2个条件：

1.转换前的数据类下与转换后的数据类型要兼容。

2.转换后的数据类型要比转换前的数据类型表示范围大。（即由小转大，可以实现自动类型转换）。

2.强制类型转换

(欲转换的类型）变量名 如：

int a=13; short a=(short)a

8.输入流

---

输入输出流的类层次图

1.常用的System类（位于System.lang包）

常用的3个字段：in，out，err

2.InputStream类：

常用方法：

3. PrintStream类的常用方法

4.java.util.Scanner类

参考地址：java8文档

Scanner类的常用构造方法

Scanner类的常用方法

1.close() 关闭此扫描仪。

2.hasNext() 如果此扫描仪在其输入中有另一个令牌，则返回true。

3.hasNext(Pattern pattern) 如果下一个完整的令牌匹配指定的模式，则返回true。

4.hasNextFloat() 如果扫描仪输入中的下一个标记可以使用 nextFloat()方法将其解释为浮点值，则返回true。

5.hasNextInt() 如果此扫描仪输入中的下一个标记可以使用 nextInt()方法解释为默认基数中的int值，则返回true。

6.hasNextLine() 如果扫描仪的输入中有另一行，则返回true。

7.next() 查找并返回此扫描仪的下一个完整令牌。

5.FileInputStream类

6.FileOutputStream类

7.FileDescriptor类

9.输入输出缓冲流

---

9.1 字节输入输出缓冲流

1.BufferedInputStream

常用字段：

1.protected byte[] buf

存储数据的内部缓冲区数组。

2.protected int count

索引一大于缓冲区中最后一个有效字节的索引。

3.protected int marklimit

mark方法调用后，最大超前允许，后续调用 reset方法失败。

4.protected int markpos

pos字段在最后一个 mark方法被调用时的值。

5.protected int pos

缓冲区中的当前位置。

构造方法

常用方法：

2.BufferedOutputStream

9.2 字符输入输出缓冲流

1.BufferedReader

2.BufferedWriter

10.File文件类

---

1.常用字段

2.构造方法

3.常用方法

1.boolean exists()

测试此抽象路径名表示的文件或目录是否存在。

2.File getAbsoluteFile()

返回此抽象路径名的绝对形式。

3.String getAbsolutePath()

返回此抽象路径名的绝对路径名字符串

4.String getPath()

将此抽象路径名转换为路径名字符串。

5.int hashCode()

计算此抽象路径名的哈希码。

6.boolean isDirectory()

测试此抽象路径名表示的文件是否为目录。

7.boolean isFile()

测试此抽象路径名表示的文件是否为普通文件。

8.long length()

返回由此抽象路径名表示的文件的长度。

9.boolean mkdir()

创建由此抽象路径名命名的目录。

10.mkdirs()

创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。

11.boolean renameTo(File dest)

重命名由此抽象路径名表示的文件。

11.lambda表达式

---

说白了，其实lambda表达式就是由匿名内部类转换过来的。其实它们就是为了简化接口的实现类。快速实现接口的方法。简化代码的冗余。（当然这种只适用于只有一个抽象方法的接口。）

package com.company.innerClass;

import java.security.PublicKey;

interface A{

void show();

}

public class InnerTest {

public static void main(String[] args) {

// 内部类的应用

// A a=new A(){

// public void show(){

// System.out.println(“内部类的应用”);

// }

// };

// a.show();

// lambda表达式 省略了内名、方法名、简便地创建接口地实现类对象

A a1=()->{

System.out.println(“我是lambda表达式”);

};

a1.show();

}

}

字符串常用方法

---

1.将字符串转为子杰数组：

String str=“”;

str.getBytes(); //返回值类型： byte[]

2.字符串常用的构造方法

public String():空构造

public String(byte[] bytes):把字节数组转成字符串

public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串

public String(char[] value):把字符数组转成字符串

public String(char[] value,int index,int count):把字符数组的一部分转成字符串

public String(String original):把字符串常量值转成字符串

字符串常用方法

补充：str.matches(regexp):用于正则表达式，如下：

String tel=“17985931231”;

System.out.println(tel+“满足电话格式要求吗？”+tel.matches(“1[378][0-9]{9}”));

1.返回字符串中指定位置的字符

字符串名.charAt(值)

2.返回值为 char 数组类型

字符串名.toCharArray()

3.查找一个指定的字符串是否存在，返回该字符第一次出现的位置，如果不存在，则返回-1

字符串名.indexOf(“字符”)

4.lastIndexOf(“字符”) 得到指定内容最后一次出现的下标

5.toUpperCase()； toLowerCase()；字符串大小写的转换

6.根据正则表达式形成一个新的String数组。

比较两个字符串是否相等

trim();　　去掉字符串左右空格

str.trim()

replace(char oldChar,char newChar)新字符替换旧字符，也可以达到去空格的效果一种。

substring(int beginIndex,int endIndex)　　截取字符串

boolean equalsIgnoreCase(String) 忽略大小写的比较两个字符串的值是否一模一样，返回一个布尔值

判断一个字符串里面是否包含指定的内容，返回一个布尔值

str.contains(str1)

boolean startsWith(String)　　测试此字符串是否以指定的前缀开始。返回一个布尔值

str.startsWith(str1）

endsWith(String)　　测试此字符串是否以指定的后缀结束。返回一个布尔值

str.endsWith(str1)

replace方法，用于替换字符串中的一部分内容

易错点

---

1.Exception in thread “main” java.lang.StackOverflowError

原因：两个类互相new对方，具体如下：

即（两个类中不能互相new，否则会出现栈溢出）

1.impl类

package com.example.springboot_websocket.Test;

import com.example.springboot_websocket.Test.dao;

public class impl implements dao{

protected static final int a=3;

protected final int b=10;

protected int c;

protected C c1=null;

public impl(){

this.c=20;

//impl new 了 C类

this.c1=new C();

}

}

C类

package com.example.springboot_websocket.Test;

public class C {

//C类依赖newlimpl

private dao d=new impl();

public void show(){

System.out.println(“我是C类，欢迎访问我的事件”);

// 这里虽然能够访问该接口的方法，但是d=null,报空指针异常

// d.display();

d.display();

}

public static void main(String[] args) {

new C().show();

}

}

2.接口对自身方法的访问

即使接口可以使用 " . " 显示出自己的方法或者变量，但是该接口如果没有被实例化的话（普通类也是一样的，反正都必须实例化后才可以使用），否则它是会报空指针错误的。具体案例如下：

package com.example.springboot_websocket.Test;

public class C {

private dao d=new impl();

public void show(){

System.out.println(“我是C类，欢迎访问我的事件”);

// 这里虽然能够访问该接口的方法，但是d=null,报空指针异常

// d.display();

}

public static void main(String[] args) {

new C().show();

}

}

内部类

---

普通成员内部类

代码示例

package com.demo;

/**

• 成员内部类

• 经检验：成员内部类（就是和外部类的方法具有同级结构）有如下特性：

•   1.成员内部类可以访问外部类的私有成员（那public成员肯定也是可以访问的噻）
  

•   2.外部类不可以 直接 访问 成员内部类 的成员包括方法（public的也不行）--解决办法如下：
  

•                  通过在外部类的方法里面创建 内部类的对象就可以访问内部类的公有属性了
  

*/

public class memberClass {

private String name;

public memberClass(){

name=“hjx”;

System.out.println("hello "+name);

}

public void show(){

memberClass member=new memberClass();

memberClass.innerClass inner=member.new innerClass();

inner.display();

System.out.println(“inner age”+inner.age);

System.out.println(“我是show方法”);

}

public class innerClass{

public int age;

public void display(){

System.out.println(“我是display”);

}

}

public static void main(String[] args) {

memberClass member=new memberClass();

member.show();

memberClass.innerClass inner=member.new innerClass();

}

}

new 一个普通成员内部类的对象

为什么要使用内部类

简单说：

如果不使用内部类的话，当多个模块之间要调用的话，会导致结构不清晰，一个类要完成一个功能从表面上看要依赖多个类。但是通过内部类，将其依赖的多个类放在一个外部类的里面的话（其余的功能通过该外部类的内部类来完成），这样看起来就像只依赖了这一个类一样。结构更加清晰。

方法内部类

示例代码

package com.demo;

/**

• 方法内部类

•     注意点：
  

•        1.对方法内部类实例的创建不能在方法内部类内部，需要在方法里面（且内部类的外面）
  

•        2.方法内部类可以访问外部类的私有属性
  

*/

public class methodClass {

private int age;

public methodClass(){

this.age=21;

System.out.println(“我是外部类—age=”+age);

}

public void hello(){

System.out.println(“hello”);

}

public void show(){

int height=12;

class My{

private String name;

public My(){

this.name=“yyy”;

System.out.println(“我是内部类-------name=”+name);

}

public void display(){

System.out.println(“----我是内部类的display方法—”);

System.out.println(“age=”+age);

hello();

}

}

My my=new My();

my.display();

}

public static void main(String[] args) {

methodClass mclass=new methodClass();

mclass.show();

}

}

静态内部类

示例代码

package com.demo;

/**

• 静态内部类

• 注意点：

•    1.静态内部内只能使用外部类的 静态属性(包括private修饰）
  

•    2.静态内部类可以直接在main方法创建对象，它不需要依赖外部类的对象
  

*/

public class StaticClass {

private static int age;

public StaticClass(){

System.out.println(“age=”+age);

}

public static class innerStaticClss{

private static String name;

static{

System.out.println(“这是静态内部类的static代码块”);

name=“犹元勇”;

}

public innerStaticClss(){

System.out.println(“name=”+name+“外部类的age=”+age);

}

public void show(){

System.out.println(“我是内部类的show方法!”);

}

}

public static void main(String[] args) {

StaticClass staticClass=new StaticClass();

innerStaticClss inner=new innerStaticClss();

inner.show();

}

}

匿名内部类

缺点：耦合度太高。

优点：不需要单独创建一个文件去对接口进行实现

代码示例

package com.demo;

/**

• 匿名内部类的使用

• 注意点：

•   1.匿名内部类主要是简便对接口和抽象类的实现。所以匿名内部类必须对接口和抽象类进行实现
  

•   2.使用接口和抽象类的变量来接收实例
  

*/

public class AnonymousClass {

private int age;

{

age=24;

}

public AnonymousClass(){

System.out.println(“age=”+age);

// 匿名内部类的使用

Myinterface myinterface=new Myinterface() {

@Override

public void show() {

System.out.println(“hello,show()方法”);

}

@Override

public void display() {

System.out.println(“hello,display()方法”);

}

};

myinterface.show();

myinterface.display();

}

public static void main(String[] args) {

AnonymousClass anonymousClass=new AnonymousClass();

AbstractClass abstractClass=new AbstractClass() {

@Override

public void hello() {

System.out.println(“我是hello方法”);

}

};

abstractClass.hello();

}

}

interface Myinterface{

public void show();

public void display();

}

//抽象类

abstract class AbstractClass{

public abstract void hello();

}

使用成员内部类实现接口

枚举类

---

自定义枚举类

使用enum定义枚举类

枚举类的主要方法

valueOf()的使用

代码示例

package com.demo2_enum;

/**

• 使用enum定义的枚举类默认使用Enum作为其父类

• 注意点：

•    1.枚举成员：可称为枚举实例 / 枚举对象
  

•    2.枚举值之间需用 逗号 分隔，但最后一个用 分号 结尾。
  

•    3.枚举类的构造方法只能使用private修饰
  

•    4.枚举成员默认使用public static final 修饰
  

*/

class Main{

// Enum类的compareTo(E o)的使用 返回枚举成员与参数成员o在定义时的顺序比较结果

public void compareMethod(User user){

User myuser=User.XIAOMING;

// 这里其实就是用 myuser对象的序号 减去 user的序号 这里myuser在前面 ，所以返回负数

System.out.println("比较结果----- "+myuser.compareTo(user));

}

// 序号从0开始

public void OrdinalUse(){

// 获取所有枚举成员

User[] users=User.values();

for (User user:users){

System.out.println(“枚举成员 及其 序号如下：”);

System.out.println(user.ordinal()+" "+user);

}

}

/*

枚举类型中的 泛型方法 valueOf(Class enumType,String name)的使用

返回指定枚举类型、指定名称的枚举成员

*/

public void getSpecificMember(){

System.out.println(“--------valueOf(Class enumType,String name)的应用如下：--------”);

User user=User.valueOf(User.class,“YYY”);

System.out.println(user);

}

public static void main(String[] args) {

Main main=new Main();

User user=User.XIAOMING;

System.out.println(“枚举类User的父类是:”+user.getClass().getSuperclass());

// System.out.println(“user=”+user); // user=XIAOMING(只打印出名字）

// 如果提供该枚举类的toString方法，则打印toString()的内容

// System.out.println(“user=”+user); //user=User{name=‘小明’, age=21}

// values()的使用

User[] arr=User.values();

for (User item:arr){

System.out.print(item+" "); //输出枚举常量

}

// valueOf()的使用

User user1=User.valueOf(“LIFU”); // 如果没找到，则抛出 IllegalArgumentException 异常

System.out.println(“user1=”+user1);

// 使用enum类实习的接口

user1.show(); // 我是接口的 show方法

// 对每一个枚举类对象实习同一个接口（但是行为不同）

/* User user2=User.XIAOMING;

user2.show();

User user3=User.LIFU;

user3.show();

User user4=User.YYY;

user4.show();*/

main.compareMethod(user1); // 这里user1：LIFU

main.OrdinalUse();

main.getSpecificMember();

}

}

interface MyInterface{

public void show();

}

enum User implements MyInterface{

XIAOMING(“小明”,21){

@Override

public void show() {

System.out.println(“XIAOMING--------我是接口的 show方法”);

System.out.println(“*******************************************”);

}

},

LIFU(“李福”,22){

@Override

public void show() {

System.out.println(“LIFU--------我是接口的 show方法”);

System.out.println(“*******************************************”);

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

// System.out.println(“user=”+user); // user=XIAOMING(只打印出名字）

// 如果提供该枚举类的toString方法，则打印toString()的内容

// System.out.println(“user=”+user); //user=User{name=‘小明’, age=21}

// values()的使用

User[] arr=User.values();

for (User item:arr){

System.out.print(item+" "); //输出枚举常量

}

// valueOf()的使用

User user1=User.valueOf(“LIFU”); // 如果没找到，则抛出 IllegalArgumentException 异常

System.out.println(“user1=”+user1);

// 使用enum类实习的接口

user1.show(); // 我是接口的 show方法

// 对每一个枚举类对象实习同一个接口（但是行为不同）

/* User user2=User.XIAOMING;

user2.show();

User user3=User.LIFU;

user3.show();

User user4=User.YYY;

user4.show();*/

main.compareMethod(user1); // 这里user1：LIFU

main.OrdinalUse();

main.getSpecificMember();

}

}

interface MyInterface{

public void show();

}

enum User implements MyInterface{

XIAOMING(“小明”,21){

@Override

public void show() {

System.out.println(“XIAOMING--------我是接口的 show方法”);

System.out.println(“*******************************************”);

}

},

LIFU(“李福”,22){

@Override

public void show() {

System.out.println(“LIFU--------我是接口的 show方法”);

System.out.println(“*******************************************”);

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-IivZN5Au-1715728254567)]

[外链图片转存中…(img-hXYlV17A-1715728254568)]

[外链图片转存中…(img-OZx2A9Be-1715728254568)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！