学习笔记-JavaSE(1)

1. 概述

计算机语言简史

主要阶段

1. 机器语言（打孔机）
2. 低级语言（汇编）
3. 高级语言（Java）

Java发展简史

Java语言特性

简单
面向对象
可移植性（一次编译，到处执行）
健壮性（自动垃圾回收机制）
多线程

Java的加载与执行

编译阶段

graph TB
源文件-->字节码文件

运行阶段

graph TB
字节码文件-->类装载器
类装载器-->JVM
JVM-->操作系统
操作系统-->硬件平台

2. Java语言基础

标识符

可以标识类名、变量名、接口名和方法名

1. 命名规则
   1. 标识符有 数字、字母、下划线和美元符构成
   2. 必须以 字母、下划线、或美元符 开头
2. 关键词不能作为标识符
3. 标识符区分大小写
4. 标识符理论上没有长度限制

关键字

都是 小写

class	extends	implements	interface	import
package	break	case	continue	default
do	if	else	for	return
switch	while	false	true	null
boolean	byte	char	short	int
long	float	double	try	catch
throw	throws	finally	abstract	final
native	private	protected	public	static
synchronized	transinet	volatile	instanceof	new
super	void	assert	enum	goto
const

数据类型

基本类型和引用类型，基本类型有 8 种，引用类型有 3 种

• 基本数据类型
  • 数据类型
    • 整数型（byte、short、int、long）
    • 浮点型（float、double）
  • 字符类型（char）[2B,Unicode]
  • 布尔型（boolean，只能取值 true 和 false ，默认 false）
• 引用数据类型
  • 数组
  • 类
  • 接口

进制换算

字符编码

• ASCII码 采用一个字节编码，主要针对英文编码

  a:97 A:65 0:48

• ISO-8859-1 主要为了西欧语言中的字符编码和ASCII兼容

• GBK 主要是汉字编码

• Unicode 统一了全世界上的所有文字编码，有UTF-8、UTF-16、UTF-32。

字符如果采用的编码和解码不一致时，会出现乱码。

关于转义字符

转义字符	作用
\t	制表符（Tab）
\n	换行
\\	\
\’	’
\"	"
\u	Unicode码转换

数据类型

整数型

byte（1B，-128–127）

short/int/long

三种表示方法

• 十进制
• 八进制，0开头
• 十六进制，0x开头

Java语言整数类型默认为int类型，如果要声明生long类型在变量值后加L，如：

long l = 9999999L

如果这个整数（字面值）没有超出byte的取值范围，可以直接将这个整数类型赋值给byte类型。

如果这个整数没有超出short的取值范围，可以直接将这个整数类型赋值给short类型。

如果这个整数没有超出char的取值范围，可以直接将这个整数类型赋值给char类型。

浮点类型

float 4B

double 8B

默认为double

布尔类型

只有true/false两个值，没有1和0

主要用在逻辑运算和条件控制语句中

基本数据类型的转换

• 在Java中基本类型可以互相转换，只有boolean类型不可以
• 转换分为自动转换和强制转换
  • 自动转换：容量小的类型会默认转换为容量大的类型：
    • byte–>short、char–>int–>long–>float–>double
    • byte、short、char之间做混合运算时不会互相转换，首先转换成 int
  • 强制转换：
    • 将容量大的类型转换成容量小的类型，需要进行强制转换
    • 注意：只要不超出范围可以将整数值直接赋值给byte、short、char
• 在多种类型混合运算时，会都先转换为最大容量的类型再进行运算。

运算符

算术运算符

+ 求和

- 相减

* 相乘

/ 相除

++ 自加：

++ 如果出现在变量后面，先赋值再自加

++ 如果出现在变量前面，先自加再赋值

-- 自减：

% 取模

关系运算符

<

<=

>=

==

!=

布尔运算符

&&

||

&

|

!

^

位运算符

& 按位与

| 按位或

^ 按位异或

~ 按位非

>> 右移

>>> 右移，左边空出来的以0填充

<< 左移

赋值类运算符

=

+=

-=

*=

/=

%=

字符串连接运算符

+

+两边只要都是数字类型，一定是加法运算

任意一端只要是字符串类型，一定是字符串连接

条件运算符

?:

语法：boolean表达式?A:B

boolean为true，表达式结果为A，否则为B

其他运算符

instanceof

new

控制语句

java控制语句分为7种：

• 控制选择结构语句

  • if、if else

  • switch

    语法：

    switch(int){
     case int:
         java;
       	java;
         break;
     case int:
         java;
         java;
         break;
     default:
         java;
    }
    

• 控制循环结构语句

  • for
  • while
  • do while

• 改变控制语句顺序

  • break
  • continue

方法（method）初步

方法：代码片段，可以重复利用

语法：

[修饰符列表] 方法的返回值类型 方法名(方法的形参列表){
    javacode;
}

修饰符列表是可选的

返回值类型可以是java语言中的任何一种数据类型，如果没有返回值，返回值写：void

方法名只要是合法的标识符即可

方法重载

同一个类中方法名相同，参数列表（类型、个数、顺序）不同发生重载。

如果参数列表相同，则编译不通过。

方法的重载与方法的返回值类型、修饰符无关，只与参数列表有关。

方法的执行原理：

方法在调用时，才会给该方法在内存中分配空间。

如果这个方法只是定义没有调用，则不会再内存中分配空间。

方法调用时在“栈”中分配空间

方法调用其实就是“入栈”

方法结束就是“出栈”

3. 面向对象

面向对象的三大特性：

• 封装
• 继承
• 多态

面向对象编程可分为三个阶段：

• OOA 面向对象分析
• OOD 面向对象设计
• OOP 面向对象编程

类的定义

类修饰符 class 类名 extends 父对象名称 implements 接口名称{
   属性和方法
}

示例：

// Student.java
public class Student{
    //属性
    int id; // 成员变量是对象级别的，必须先有对象级别才能访问
    String name;
    boolean sex;
    int age;
    String addr;
    //方法
}

对象的创建和使用

// 1. 创建对象
// stu是一个局部变量（栈），这个局部变量是Student类型，也就是一个引用类型,存储实例对象的内存地址
Student stu = new Student();
// Java中所有new出来的的数据统一存储在堆中，程序员无法对堆进行操作，只能通过内存地址间接操作
// 实例对象的成员变量是对象相关的，成员变量在堆中的对象里存储
// 成员变量如果没有手动赋值，系统默认赋值

// 所用引用类型默认： null

// 2. 使用对象
// 访问成员变量，必须使用 引用.变量
// name是成员变量，对象相关，必须先有对象才能访问，必须使用引用
System.out.println(stu.name);

// 赋值
stu.name = "zhansan";

封装性

面向对象的封装性是指：

1. 属性私有化
2. 对外提供公开的接口

//Customer.java
public class Customer{
    
    // 属性
    private int age; // private修饰的数据只能在本类中使用
    
    // 对外提供公开方法
    // setter
    public void setAge(int age){
        // 安全控制
        if(age < 0 || age > 100){
            return;
        }else{
        	this.age = age;
        }
    }
    // getter
    public int getAge(){ // 成员方法
        return age;
    }
}
//OOTest02
import Customer

pubilc class OOTest02{
	public static void main(String[] args){
        // 创建
        Customer c = new Customer;
        // 读取
        System.out.println(c.getAge());
        // 赋值
        c.setAge(10);
        // 读取
        System.out.println(c.getAge())
    }
}

构造函数（构造方法、构造器）

构造方法：

[修饰符] 类名(形参列表){
	方法体;
}
// 如果一个类没有提供任何构造方法，系统默认提供无参数构造方法；
// 如果一个类提供了构造方法，系统不会提供任何构造方法；


// 调用
new 类名(实参); //在堆中开辟空间存储对象

1. 无返回值类型
2. 构造方法作用
   • 创建对象
   • 初始化成员变量

// User.java
public class User{
    
    int age;
    boolean sex;
    
    public User(){
        
    }
    
    public User(int age){
        this.age = age;
    }
    
    public User(int age,boolean sex){
        this.age = age;
        this.sex = sex;
    }
}

// OOTest03.java
public class ConstructorTest01{
	public static void main(String[] args){
        User user1 = new User(12,true);
        User user2 = new User();
        User user3 = new User(13);
    }
}

Java内存的主要划分

• 堆区：存放new出来的对象，此对象由垃圾回收器收集，垃圾收集器针对的就是堆区（如果堆中的对象没有更多引用指向，将被回收）

• 栈区：每调用一个方法，会创建一个栈帧，存放局部变量

• 方法区：类的所有信息，包括所有的方法，静态变量，常量

public class OOTest03{
    public static void main(String[] args){
        // u1 是引用 指向User对象
        User u1 = new User();
        
        // User对象变成了垃圾
        u1 = null;
		
        System.out.println(ul.name); //java.lang.NullPointerException（空指针异常）
        
        Star s = new Star();
        s = null;
        s.print(); // java.lang.NullPointerException（空指针异常）
    }
}

参数传递

程序在执行过程中，参数的传递问题：

1. 传递的数据是基本数据类型
2. 传递的数据是引用数据类型

2传递的是内存地址，修改会改变

this关键字

任何对象都存在this变量（引用类型），指向自身（内存地址）

public class ThisTest01{
    public static void main(String[] args){
        MyDate t1 = new MyDate(2008,8,8);
        
        MyDate t2 = new MyDate(2012,12,20);
    }
}

class MyDate{
    
    int year;
    int month;
    int day;
    
    // ! 通过一个构造方法调用另一个构造方法
    MyDate(){
        this(1970,1,1); // 必须出现在第一行
    }
    // this 能用在构造方法中
    // this 可用来区分成员变量和局部变量
    MyDate(int year,int month,int day){
        this.year = year;
        this.month =month;
        this.day = day;
    }
    // this 能用在成员方法中代表当前对象，可省略
    public void getMyDate(){
        return this.year+"-"+this.month+"-"+this.day;
    }
    // this 不能用在静态方法中
}

static关键字

static修饰的变量和方法不是成员变量

1. static修饰的变量叫做静态变量
2. static修饰的方法叫做静态方法
3. static还可以定义静态语句块

public class StaticTest01{
    // 静态语句块
    // 类加载时就会执行，并且只执行一次,自上而下的顺序执行
    static{
        System.out.println("1");
    }
    static{
        System.out.println("2");
    }
}

关于实例语句块

每次调用 构造方法之前 都会执行一次

执行顺序自上而下

public class StaticTest02{
	// 静态语句块
    static{
        sout("A");
    }
    static{
        sout("1");
    }
    // 实例语句块
    {
        sout("3");
    }
    StaticTest02(){
        sout("构造函数执行");
    }
    public static void main(String[] args){
        
        new StaticTest02();
    }
}

静态方法

静态方法为static关键字修饰的方法

工具类中的大部分方法都是静态方法

静态方法不需要创建对象就可以使用

public class StaticTest02{
    // 引用.函数名
	public void m1(){
        
    }
    // 类名.函数名 or 引用.函数名
    // 不能直接访问非静态数据
    // 不能使用this
    public static void m2(){
        
    }
    public static void main(String[] args){
        StaticTest02 st = new StaticTest02();
        st.m1();
        
        // static函数中调用static函数
        m2();
        
        // 使用引用调用static函数,运行时仍然使用
        // StaticTest02. 的方式访问
        st.m2();
        
        // 空的引用去访问成员的时候回出现空指针异常
        // m2 方法不是成员而是静态的
        // 所以即使引用是空的,也不会报空指针异常
        st = null;
        st.m2();
    }
}

静态变量

类共有的属性设置为静态变量

成员变量:在创建java对象的时候初始化

静态变量:在类加载的阶段赋值,并且只赋值一次

类{
		成员变量
    	成员函数
            
        静态方法
        静态函数
        
        实例代码块
        静态代码块
        
        构造函数
        this
}

变量分类：

• 局部变量
• 成员变量（实例变量、非静态变量）
• 静态变量（存放在方法区）

成员变量在创建对象时初始化,并且存储在堆中的每一个对象中

静态变量,被存储在方法区,所有同类java对象共享一份

所有静态变量是类级别的

关于代码顺序

public class Test{
    
    static int i = 100;
    
    // 静态代码块
    static{
        System.out.println(i);
    }
    
    public static void main(String[] args){
        
    }
}

单例模式

== 可比较两个对象

两边如果是基本数据类型,比较的是值

如果是引用类型,比较内存地址

// Singleton.java
public class Singleton{
    
    private static Singleton s;
    
    // 将构造方法私有化
    private Singleton(){
        
    }
    
    // 对外提供公开获取Singleton对象的方法
    public static Singleton getInstance(){
        // 懒汉式单例模式
        if(s==null){
            s = new Singleton;
        }
        // 饿汉式 类加载式创建
        // 懒汉式 第一次请求时创建
        return s;
    }
}

类的继承

作用:

• 代码重用
• 实现多态

java 只支持单继承

一个类默认继承Object,Object是java的根类

// Account.java
public  class Account{
    
    private String actno;
    
   	double balance;
    
    Account(){}
    
    Account(String actno,double balance){
        this.actno = actno;
        this.balance = balance;
    }
    
    public void setActno(String actno){
		this.actno = actno;
    }
    
    public String getActno(){
        return actno;
    }
}
// DebitAccount.java
/*
	java语言子类继承父类,会将父类中所有的数据全部继承,包括
	私有的.但是在子类中无法直接访问父类中的私有数据,可以间接
	(通过父类提供的接口)访问
	
	注意,构造方法无法被继承
*/
public class DebitAccount extends Account{
    
   	double debit;
    
}

方法的覆盖

如果父类中的方法无法满足当前子类的业务要求,需要将父类中的方法重新写一遍.

子类如果重写父类中的方法之后,子类对象一定调用的是重写后的方法.

发生方法覆盖的条件:

1. 发生再具有继承关系的两个类之间
2. 相同方法名,相同的返回值类型,相同的参数列表
3. 重写的方法不能比被重写的方法拥有更低的访问权限
4. 重写的方法不能比被重写的方法跑出更宽泛的异常
5. 私有的方法不能被覆盖
6. 构造方法无法被覆盖
7. 静态方法不存在覆盖
8. 覆盖指的是成员方法,与成员变量无关

class Animal{
	public void move(){
        sout("动物在移动");
    }    
}

class Cat extends Animal{
    // 方法的覆盖 重写 overwrite override
    public void move(){
        sout("猫在移动");
    }
}

class Dog extends Animal{
    public void move(){
        sout("狗在移动")
    }
}

多态

关于java语言中的向上转型和向下转型

1. 向下转型:强制类型转换
2. 向上转型:自动类型转换

两个类之间必须要有继承关系

public class Animal{
    public void eat(){
        
    }
}
public class Cat extends Animal{
    public void eat(){
        sout("猫吃鱼");
    }
    public void move(){
        sout("猫移动")
    }
}
public class Test{
    public static void main(String[] args){
        // 编译阶段只知道a1是一个Animal类型
        // 运行时堆中的实际对象时Cat类型
        Animal a1 = new Cat();
        
        // 程序在编译阶段a1被看作Animal类型
        // 即编译阶段:a1绑定的是Animal的方法(静态绑定)
        // 程序运行时,堆中的对象实际上是Cat类型,而Cat
        // 已经重写了eat方法.所以运行时绑定的时Cat中的
        // eat方法(动态绑定)
        a1.eat(); // 猫吃鱼
        
        Animal a2 = new Cat();
        
        // a2.move(); // 报错
        // 进行强制类型转换
        Cat c1 = (Cat)a2;
        c1.move();
        
        Animal a3 = new Dog();
        Cat c2 = (Cat)a3; //编译通过,运行出错
        // java.lang.ClassCastException
        
    }
    
}

instanceof 返回boolean类型

引用 instanceof 类型

在做向下转型时使用该函数做判断

多态的好处

面向父类编程,方便业务的扩展

1. 使用多态可以使代码之间的耦合性降低
2. 项目的扩展能力增强

私有的方法无法被覆盖

class A{
    
    private void m1(){
        sout("a.m1")
    }
    
    public static void main(String[] args){
        
        A a = new B(); 
        
        a.m1(); // out: a.m1
    }
}
class B extends A{
    
    public void m1(){
        sout("b.m1");
    }
    
}

静态方法不存在覆盖

public class Test03(){
	public static void main(String[] args){
        A a = new B();
        a.m1(); // a.m1
    }
}

class A{
    public static void m1(){
        sout("A.m1");
    }
}

class B{
    public static void m1(){
        sout("B.m1");
    }
}

super 关键字

1. super 不是引用类型,存储的不是内存地址,super指向的不是父类对象
2. super代表的是当前子类对象中的父类型特征
3. 子类和父类中都有某个数据,需要访问父类的数据时使用
4. super可用成员方法中,构造方法中,不能用在静态方法中

// Employee.java
public Employee{
    
    String name = "张三";
    
    public void work(){
        sout("员工在工作");
    }
}

// Manager.java
public Manager{
    
    String name = "李四";
    
    // 重写work方法
    public void work(){
        sout("经理在工作");
    }
    public void m1(){
        work();
        // 如果work没有被重写,那么执行的是父.work
        // 否则,执行覆盖后的work
        super.work();
        // 执行父.work
    }
}

super():通过子类的构造方法调用父类的构造方法

一个构造方法第一行如果没有this(…)也没有super(…),则默认调用super()

super():的调用只能放在构造函数的第一行,不能共存

可以给当前子对象中的父类型特征赋值,不会创建父类对象

所有类都会执行构造方法时都会执行super方法

单例模式的类型没有子类,无法被继承

final关键字

• final修饰的类无法被继承(java.lang.String)

• final修饰的方法无法被覆盖

• final修饰的局部变量一旦赋值,无法再改变

• final修饰的成员变量必须显示的初始化,不能默认赋值

class A{
    // 1
    final int i = 100;
    // 2
    final int k;
    A(){
        k=100;
    }
    // 3
    final int t; //编译不通过
}

• final修饰的成员变量一般和static联用(常量标识符大写)

抽象类

• 抽象类无法被实例化

public abstact class A{
    A(){
        
    }
    public abstract void m1();
}

class B extends A{
    B(){
        super(); 
        // 父类构造方法虽然调用了,但是并没有创建父类对象
    }
    
    public void m1(){
        
    }
}

• 虽然抽象类无法实例化,但是抽象类也有构造方法,该方法时给子类创建对象用的

• 抽象类中可以定义抽象方法

• 抽象类中不一定有抽象方法,但抽象方法必须出现在抽象类中

• 一个 非抽象 的类继承抽象类,必须将抽象类中的抽象方法覆盖

• 抽象类 抽象方法不能被final修饰

接口

接口也是一种引用类型,等同类:

1. 接口中只能出现:常量 抽象方法

2. 接口其实是一个特殊的抽象类,完全抽象

3. 接口中**没有构造方法,**无法被实例化

4. 接口和接口之间可以多继承

5. 一个类可以实现多个接口

6. 一个非抽象的类实现接口,需要将接口中所有的方法重写

public interface A{
    
    // 常量
    public static final String SUCCESS = "success";
    public static final double PI = 3.14;
    // public static final可以省略
    byte MAX_VALUE = 127; //常量
    
    // 抽象方法
    public abstract void m1();
    // public abstact是可以省略的
    void m2();
}

interface B{
    
}

interface C extends A,B{
    
}

class D implements A,B,C{
    ...
}

implements是实现的意思,是一个关键字

Object类

toString() :

返回java对象的字符串表示

Object: return classname + hex

在现实的开发过程中,Object的toString方法已经不够用

通常重写toString()方法

sout(引用.toString()) == sout(引用)
// print方法后括号中如果是一个引用类型,会调用toString

equals() :

指示与其他某个对象是否一样

Object中equals方法:如果为引用类型,比较内存地址

Object: return this == object

String 不是基本数据类型,已经重写equals方法

所以比较字符串是否一致,使用equals

finalize() :

垃圾回收

包和import

软件包机制

1. 为了解决类的命名冲突问题,在类名前加包名空间

2. 在java中使用 package 语句定义包

3. package 语句只能出现在java源文件的第一行

4. package定义的格式,通常采用公司域名倒叙方式

5. 完整的类名是带包名的

6. 带有package语句的java源文件必须这样编译:

   ​ java -d 生成路径 java源文件路径

访问控制权限

修饰符	类的内部	同一个包	子类	任何地方
private	y	n	n	n
protected	y	y	y	n
public	y	y	y	y
default	y	y	n	n

内部类

静态内部类

1. 等同看待静态变量
2. 静态内部类可以直接访问外部类的静态数据,无法访问成员

public class OuterClass{
    // 静态方法
    private static String s1 = "A";
    // 成员方法
    private String s2 = "B";
    
    private static void m1(){
        sout("static.m1 method execute!")
    }
    
    private void m2(){
        sout("m2 method execute!")
    }
    
    // 静态内部类
    // 可以用访问空去权限修饰符 修饰
    static class InnerClass{
    	
        // 静态方法
        public static void m3(){
            sout(s1);
            // sout(s2);
            
            m1();
            // m2();
        }
        // 成员方法
        public void m4(){
            sout(s1)
        }
    }
    
    public static void main(String[] args){
        OuterClass.InnerClass.m3();
        
        InnerClass inner = new OuterClass.Innerclass();
        inner.m4();
    }
    
}

成员内部类

1. 等同看待成员变量
2. 成员内部类中不能有静态声明
3. 成员内部类可以访问外部类中私有的数据

public class OuterClass{
    // 静态方法
    private static String s1 = "A";
    // 成员方法
    private String s2 = "B";
    
    private static void m1(){
        sout("static.m1 method execute!")
    }
    
    private void m2(){
        sout("m2 method execute!")
    }
    
    // 成员内部类
    // 可以用访问空去权限修饰符 修饰
    class InnerClass{
    	
        // 成员内部类不能有静态方法
        // public static void m3(){
        // }
        
        // 成员方法
        public void m4(){
            sout(s1)
        }
    }
    
    public static void main(String[] args){
        OuterClass oc = new OuterClass();
        
        InnerClass inner = oc.new InnerClass();
        
        inner.m4();
    }
    
}

局部内部类

相当于局部变量

重点,局部内部类在访问局部变量是时,局部变量必须使用final修饰

public class OuterClass{
    
    public void m1(){
        
        final int i = 0;
        
        // 局部内部类不能访问控制权限修饰符修饰
        class InnerClass{
            
            // 内部类不能有静态声明
            // public static void m1(){}
            
            // 成员方法
            public void m1(){
                sout(i)
            }
        }
        
        InnerClass inner = new InnerClass();
        inner.m2();
    }
    
    public static void main(String[] args){
        OuterClass oc = new OuterClass();
        oc.m1();
        
    }
}

匿名内部类

public class Test{
    
    public static void test(CustomerService cs){
        cs.logout();
    }
    
    public static void main(String[] args){
        
        // new CustomerService(){} 就是个匿名内部类
        test(new CustomerService(){
            public void logout(){
                sout("system logout!")
            }
        });
        // 优点,少定义一个类
        // 无法重复使用
    }
}

interface CustomerService{
    
    // 退出系统
    void logout();
}

4. 异常

概念

/*
异常:模拟现实生活中不正常的事件
Java中采用 类 去模拟异常
一个异常类的对象表示一个异常
异常机制:健壮性
*/ 
public class ExceptionTest01{
    
    public static void main(String[] args){
        
    }
    
}

分类

异常的继承结构图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IFOcr14F-1612419381467)(C:\Users\LiTangMM\AppData\Roaming\Typora\typora-user-images\image-20191126100033432.png)]

处理异常的方式

1. 声明抛出

   使用throws处理异常不是真正处理异常而时推卸责任，谁调用抛给谁

import java.io.*;

public class ExceptionTest03{
    
    public static void main(String[] args) throws FileNotFoundExcepion{
        
        // 创建文件输入流,读取不存在文件
        // 因为FileInputStream这个构造方法在声明的位置生使用了throws FileNotFoundExceptions
        FileInputStream fis = new FileInputStrean("C:/ab.txt");
    }
    
}

2. 捕捉

   catch可以写多个,从上到下,从小到大.

   exception.printStackTrance(); //打印异常堆栈信息

   exception.getMessage(); //

自定义异常

编译时异常,直接继承Exception

运行时异常,直接继承RunTimeException

public class IllegalNameException extends Exception{
    
    public IllegalNameException(){}
    
    public IllegalNameException(String msg){
        super(msg);
    }
    
}

public class CustomerService{
    
    public void register(String name) throws IllegalNameException{
        
        if(name.length()<6){
            // 创建异常
            IllegalNameException e = new IllegelNameException("to short");
            // 抛出异常
            throw e;
        }
        
    }
    
}

public class Test{
    public static void main(String[] args){
       	
    }
}

方法覆盖与异常

重写的方法不能比被重写的方法跑出更宽泛的异常

5. 数组

数组是一种引用类型

数组是一种简单的数据结构

数据是一个容器,可以用来存储其他元素

数组可以存储任何类型,但是同一数组只能存储同类型元素

数组长度不可改变

public class ArrayTest01{
    
    public static coid main(String[] args){
        // 静态初始化
        int[] a1 = {100,200,150,300};
        boolean[] b1 = {true,false,true};
        String[] strs = {"AB","CD","EF"};
        //动态初始化
        int[] a2 = new int[4]; // int[] a1 = {0,0,0,0};
        a[0] = 1;
        a[2] = 3;
        //数组做参数
        m1(new int[]{1,2,3});
        m1(a1);
    }
    
}

数组拷贝

System.arraycopy(原数组,开始下标,目标数组,开始下标,拷贝长度)

public class Utils{
    public static void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length){ 
        for(int i = 0; i < length;i++){
            dest[destPos+i] = src[srcPos+i]
        }
    }
}

二维数组

二维数组的每一个元素都是一位数组.

public class ArrayTest09{
    
    public static coid main(String[] args){
        
        // 静态化初始二维数组
        int[][] a = {
            {1,2,3},
            {45,34},
            {0},
            {10,23,85,99}
        };
        
        // 动态初始化
        int[][] b = new int[3][4];
        
    }
    
}

Arrays工具类

java.util.Arrays

Arrays.sort():排序

Arrays.binarySearch():二分查找

Arrays.copyof(value,length):从头开始拷贝指定长度

Arrays.copyOfRange(value,start,end):拷贝指定范围

接受用户输入

java.util.Scanner

public KeyInput{
    
    public static void main(String[] args){
        
        Scanner s = new Scanner(System.in);
        
        String userInput = s.next();
        
    }
}

6. 常用类

CharSequence 是一个接口,String,StringBuffer,StringBuilder实现了它

String

重要方法:

public int length() {} // 字符串长度
public boolean isEmpty() {} // 字符是否为空
public char charAt(int index) {} // 索引为index的字符
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {} // 拷贝字符数组

public String[] split(String regex, int limit) {} // 分割字符串
public static String join(CharSequence delimiter, CharSequence... elements) {} // 第一个参数为连接符,第二个为多个CharSequence对象
public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {} // 第一个为连接符,第二个CharSequence集合

public String toLowerCase() {} // 小写
public String toUpperCase() {} // 小写
public String trim() {} // 去除左右空格

public String toString() {} // return this
public char[] toCharArray() {} // return value
public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
} // 使用args代替format的占位符

public boolean startsWith(String prefix, int toffset) {} //判断前缀
public boolean startsWith(String prefix) {}
public boolean endsWith(String suffix) {} // 判断后缀
// 正则表达式:
public boolean matches(String regex) {} 
public boolean contains(CharSequence s) {} // 是否包含
public String replaceFirst(String regex, String replacement) {}
public String replaceAll(String regex, String replacement) {}

public final class String{	
    // 主要属性
    private final char value[];
    private int hash;
    // 构造方法
	public String() {}
	public String(String original) {}
    public String(char value[]) {}
    
    public String(char value[], int offset, int count) {}
    public String(int[] codePoints, int offset, ins count) {}
    @Deprecated 
    public String(byte ascii[], int hibyte, int offset, int count) {}
    public String(byte ascii[], int hibyte) {}
    public String(byte bytes[], int offset, int length, String charsetName) {}
    public String(byte bytes[], int offset, int length, Charset charset) {}
    public String(byte bytes[], String charsetName) {}
    public String(byte bytes[], Charset charset) {}
    public String(byte bytes[], int offset, int length) {}
    public String(byte bytes[]) {}
    public String(StringBuffer buffer) {}
    public String(StringBuilder builder) {}
    String(char[] value, boolean share) {}
    
    // 方法
    public int length() {} // 字符串长度
    public boolean isEmpty() {} // 字符是否为空
    public char charAt(int index) {} // 索引为index的字符
    public int codePointAt(int index) {} 
    public int codePointBefore(int index) {}
    public int codePointCount(int beginIndex, int endIndex) {}
    public int offsetByCodePoints(int index, int codePointOffset) {}
    
    public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {} // 拷贝字符数组
    public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {}
    
    public byte[] getBytes(String charsetName) {} // 字符转编码byte
    public byte[] getBytes(Charset charset) {}
    public byte[] getBytes() {}
    
    public boolean equals(Object anObject) {} // 与(String)anObject比较是否相等
    public boolean contentEquals(StringBuffer sb) {} 
    public boolean contentEquals(CharSequence cs) {} // 与 StringBuffer, StringBuilder比较
    
    public boolean equalsIgnoreCase(String anotherString) {} //忽视大小写比较
    public int compareTo(String anotherString) {} // 比较大小
    // 1. 逐字比较,不同则返回字相减 2. 否则返回长度差值
    public int compareToIgnoreCase(String str) {} // 忽视大小写比较
    public boolean regionMatches(int toffset, String other, int ooffset, int len) {} 
    public boolean startsWith(String prefix, int toffset) {} //判断前缀
    public boolean startsWith(String prefix) {}
    public boolean endsWith(String suffix) {} // 判断后缀
    public int hashCode() {} //计算hash值
    public int indexOf(int ch, int fromIndex) {} // 第fromIndex个ch的索引
    public int lastIndexOf(int ch) {} // 最后一个ch的索引
    public int indexOf(String str, int fromIndex) {} //第fromIndex个str的索引
    public int lastIndexOf(String str) {} //最后一个str的索引
    public String substring(int beginIndex, int endIndex) {} //子字符串
    public CharSequence subSequence(int beginIndex, int endIndex) {} //子字符序列
    public String concat(String str) {} // 添加后缀
    public String replace(char oldChar, char newChar) {} // 将所有oldChar替换为 newChar
    public boolean matches(String regex) {} // 正则表达式
    public boolean contains(CharSequence s) {} // 是否包含
    public String replaceFirst(String regex, String replacement) {}
    public String replaceAll(String regex, String replacement) {}
    public String replace(CharSequence target,CharSequence replacement) {}
    public String[] split(String regex, int limit) {} // 分割字符串
    public static String join(CharSequence delimiter, CharSequence... elements) {} // 第一个参数为连接符,第二个为多个CharSequence对象
    public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {} // 第一个为连接符,第二个CharSequence集合
    public String toLowerCase() {} // 小写
    public String toUpperCase() {} // 小写
    public String trim() {} // 去除左右空格
    public String toString() {} // return this
    public char[] toCharArray() {} // return value
    public static String format(String format, Object... args) {
        return new Formatter().format(format, args).toString();
    } // 使用args代替format的占位符
}

StringBuilder

线程不安全的;无cache

StringBuffer

线程安全的,cache保存最后一次输出的String

重要方法:

public StringBuffer(String str) {}
public synchronized char charAt(int index) {} //获取索引位置的Char
public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin) {} // 复制字符数组
public synchronized void setCharAt(int index, char ch) {} //设置指定索引的char
public synchronized StringBuffer append(String str) {}
public synchronized StringBuffer delete(int start, int end) {}
public synchronized StringBuffer deleteCharAt(int index) {}
public synchronized StringBuffer replace(int start, int end, String str) {}
public synchronized String substring(int start, int end) {}
public int indexOf(String str) {}
public synchronized StringBuffer reverse() {} // 翻转
// 将value输出为String,并将结果拷贝到Cache
public synchronized String toString() {}

abstract class AbstractStringBuilder {
    char[] value;
    int count; // value实际长度
}

// StringBuffer.java
public final class StringBuffer extends AbstractStringBuilder {
    // 主要属性
    // 每次修改StringBuffer都会清除Cache,存储最后一次toString结果
	private transient char[] toStringCache;
    // 构造方法
    public StringBuffer(){}
    public StringBuffer(int capacity) {}
    public StringBuffer(String str) {}
    public StringBuffer(CharSequence seq) {}
    // 方法
    public synchronized int length() {} //retrun count
    public synchronized int capacity() {} //return value.length
    
    public synchronized void ensureCapacity(int minimumCapacity) {}
    public synchronized void trimToSize() {}
    
    public synchronized void setLength(int newLength) {} //设置长度
    public synchronized char charAt(int index) {} //获取索引位置的Char
    public synchronized int codePointAt(int index) {} //获取索引位置的编码值
    public synchronized int codePointBefore(int index) {}
    public synchronized int codePointCount(int beginIndex, int endIndex) {}
    public synchronized int offsetByCodePoints(int index, int codePointOffset) {}
    public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin) {} // 复制字符数组
    public synchronized void setCharAt(int index, char ch) {} //设置指定索引的char
    // append
    public synchronized StringBuffer append(Object obj) {} 
    public synchronized StringBuffer append(String str) {}
    public synchronized StringBuffer append(StringBuffer sb) {}
    public synchronized StringBuffer append(CharSequence s) {}
    public synchronized StringBuffer append(CharSequence s, int start, int end) {}
    public synchronized StringBuffer append(char[] str) {}
    public synchronized StringBuffer append(char[] str, int offset, int len) {}
    public synchronized StringBuffer append(boolean b) {}
    public synchronized StringBuffer append(char c) {}
    public synchronized StringBuffer append(int i) {}
    public synchronized StringBuffer appendCodePoint(int codePoint) {}
    public synchronized StringBuffer append(long lng) {}
    public synchronized StringBuffer append(float f) {}
    public synchronized StringBuffer append(double d) {}
    // delete
    public synchronized StringBuffer delete(int start, int end) {}
    public synchronized StringBuffer deleteCharAt(int index) {}
    // replace
    public synchronized StringBuffer replace(int start, int end, String str) {}
    // sub
    public synchronized String substring(int start) {}
    public synchronized CharSequence subSequence(int start, int end) {}
    public synchronized String substring(int start, int end) {}
    // insert
    public synchronized StringBuffer insert(int index, char[] str, int offset, int len) {}
    public synchronized StringBuffer insert(int offset, Object obj) {}
    public synchronized StringBuffer insert(int offset, String str) {}
    public synchronized StringBuffer insert(int offset, char[] str) {}
    public StringBuffer insert(int dstOffset, CharSequence s) {}
    public synchronized StringBuffer insert(int dstOffset, CharSequence s,int start, int end) {}
    public  StringBuffer insert(int offset, boolean b) {}
    public synchronized StringBuffer insert(int offset, char c) {}
    public StringBuffer insert(int offset, int i) {}
    public StringBuffer insert(int offset, long l) {}
    public StringBuffer insert(int offset, float f) {}
    public StringBuffer insert(int offset, double d) {}
    // 查找str位置
    public int indexOf(String str) {}
    public synchronized int indexOf(String str, int fromIndex) {}
    public int lastIndexOf(String str) {}
    public synchronized int lastIndexOf(String str, int fromIndex) {}
    
    public synchronized StringBuffer reverse() {} // 翻转
    // 将value输出为String,并将结果拷贝到Cache
    public synchronized String toString() {}
}

基础类型对应的8个包装类

基本数据类型	包装类型
byte	java.lang.Byte;
short	java.lang.Short;
int	java.lang.Integer;
long	java.lang.long;
float	java.lang.Float;
double	java.lang.Double;
boolean	java.lang.Boolean;
char	java.lang.Character;

基本数据类型–包装–>引用类型

重要方法:

public final class Integer{
    static Integer cache[]; // 常量池
    static MAX_VALUE;
    static MIN_VALUE;
    static int paseInt(String s); // 数字字符转数字

    
    static String toBinaryString(int i);
    static String toHexString(int i);
    static String toOctalString(int i);
    static String toString(int i);
    
    // 装箱
    static Integer valueOf(int i);
    static Integer valueOf(String s);
    public int intValue(); // 拆箱
    
    public String toString();
    
}
// 自动装箱拆箱 after jdk1.5
pubic class test{
    public static void main(String[] args){
      	Integet i1 = 10;
        int i2 = i1;
    }
}

1. 自动装箱和自动拆箱是编译特性,与运行无关

2. Integet类型比较是否相等不能使用 ==,Interger已经重写了Object中的equals方法.

3. 注意以下程序:

public class Test{
    // 如果数据在(-128~127)之间,java中引用了一个"整形常量池",在方法区中

    public static void main(String[] args){
        Integer i3 = 128; // 不会创建对象,直接从池中拿
        Integer i4 = 128; 
        // i3 != i4
        
        Integer i5 = 127;
        Integer i6 = 127;
        // i5 == i6
        
        Integer i7 = -128;
        Integer i8 = -128;
        // i7 != i8
        
        Integer i9 = -129;
        Integer i10 = -129;
        // i9 != i10
    }
}

日期

public class DateTest{
    import java.util.Date;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    public static void main(String[] args){
        
        // 获取系统当前时间
        Date nowTime = new Date();
        long nowTimeSS = System.currentTimeMillis(); //获取自 1970.1.1 00:00:00:000 到当前毫秒数,1000ms = 1s
        // 格式化日期
        // Date--> String
        // Y:year M:month d:day H:hour m:month s:s S:ms
        SimpleDateFormat sdf = new SimpleDateFormat('yyyy.mm.dd HH:mm:ss SSS');
        String strTime = sdf.format(nowTime);
        
        // 获取特定日期
        String strTime = "2008.08.08 08:08:08 999";
        SimpleDateFormat sdf = new SimpleDateFormat('yyyy.mm.dd HH:mm:ss SSS');
        Date time = sdf.parse(strTime); // 需要异常处理
        
        // 日历
        // 获取系统当前一个日历
        Calendar c = Calendar.getInstance();
        // 查看星期,月份,日期
        int i1 = c.get(Calendar.DAY_OF_WEEK);
        int i2 = c.get(Calendar.DAY_OF_MONTH);
        // 指定日历
        c.setTime(new SimpleDateFormat('').parse(''))
    }
    
}

数字类

// 关于数字格式化
// java.text.DecimalFromat;
/*
	# 任意数字
	, 千分位
	. 小数点
	0 不够补0
*/
import java.text.DecimalFormat;

public class NumberTest{
    
    public static void main(String[] args){
        
        DecimalFormat df1 = new DecimalFormat("###,###");
        String num1 = df1.format(1234567); // "1,234,567";
        
        DecimalFormat df2 = new DecimalFormat("###,###.##");
        String num2 = df2.format(1234567.123); //"1,234,567.12"
        
        DecimalFormat df2 = new DecimalFormat("###,###.0000");
        String num2 = df2.format(1234567.123); //"1,234,567.1230"        
    }
    
}

随机类

// 生成随机数

public class RandomTest{
    
    public static void main(String[] args){
        // 创建一个新的随机数生成器
        Random random = new Random();
        
        // int
        int i = r.nextInt(101); //[0-100]
        
    }
    
}

enum

// 定义一个枚举类型
enum Result{
    // 成功和失败
    // 规范要求 : 大写
    SUCCESS,FAIL
}
enum Season{
    SPRING,SUMMER,AUTUMN,WINTER
}