JAVA基础学习

请设置文章作者

发布于：Apr 13, 2021

次浏览

岁月悠悠 衰微只及肌肤，热忱抛却 颓废必至灵魂。**(已完结)**

面向对象

• 面向过程：当需要实现一个功能时，每一个具体的步骤都要亲力亲为，详细处理每一个细节
• 面向对象：当需要实现一个功能时，不关心具体的步骤，而是找一个以及具有该功能的，来帮我做

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

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.print("[");//面向过程
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.print(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
        System.out.println("========");
        System.out.println(Arrays.toString(array));//面向对象
    }
}

• 特点：面向对象符合我们思考习惯，可将复杂的事情简单化，并将我们从执行者变为指挥者，面向对象的语言中包含了三大基本特征，封装，继承，多态

面向对象三大特征：

封装

封装在Java中的体现

​ 1.方法就是一种封装

​ 封装就是将一些细节信息隐藏起来，对于外界不可见

​ 2.关键字private封装

​ 一旦使用private进行修饰，那么本类当中仍然可以随意访问，超出本类范围之外就不能再直接访问

​ 间接访问private成员变量，就是定义一对Getter/Setter方法

注意事项：

​ 1.当方法的局部变量和成员变量重名的时候，根据就近原则，优先使用局部变量，如果需要访问本类中的成员变量，需要使用格式：

1

this.成员变量名

​ 通过谁调用方法，谁就是this

继承

• 概述

继承主要解决的问题是共性抽取

子类可以拥有父类的内容，子类还可以拥有自己专有的内容

• 格式

在继承的关系中，子类就是一个父类，也就是说，子类可以被当作父类来看待

1.定义父类的格式

1
2
3

public class 父类名称{
  // ...
}

2.定义子类的格式

1
2
3

public class 子类名称 extends 父类名称{
    // ...
}

3.重名

在父子类继承关系当中，如果成员变量重名，创建对象时有两种方式

​ 直接通过子类对象访问成员变量

​ 间接通过成员方法访问成员变量

1
2
3
4

Zi zi = new Zi(); // 等号左边是谁，就优先用谁
System.out.println(zi.num) // 没有则向上找
System.out.println(fu.methodfu)
System.out.println(zi.methodzi) // 优先用此方法的成员变量,没有则向上找

区分子类方法中重名的三种变量

​ 局部变量：直接写

​ 本类的成员变量：this.成员变量

​ 父类的成员变量：super.成员变量

4.继承中成员方法的访问特点

创建的对象是谁，就优先用谁，如果没有则向上找

5.方法的覆盖重写(Override)

​ 概念： 在继承的关系中，方法的名称一样，参数列表也一样

​ 重写(Override)：方法的名称一样，参数列表也一样

​ 重载(Overload)：方法的名称一样，参数列表不一样

​ 特点：创建的是子类对象，则优先用子类方法

6.继承中的构造方法的访问特点

​ 1.子类构造方法中有一个默认隐含的“super( )”调用，所以一定是先调用的父类构造，后执行的子类构造

​ 2.子类构造通过super关键字来调用父类重载构造

​ 3.super的父类构造方法必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造

​ 4.子类必须调用父类构造方法，不写则赠送super()，写了则用写的super重载调用

• super关键字的三种用法

1.在子类的成员方法中，访问父类的成员变量

1

super.num // 父类中的num成员变量

2.在子类的成员方法中，访问父类的成员方法

1

super.method // 父类中的method成员方法

3.在子类的构造方法中，访问父类的构造方法

1

super() // 第一行 仅一个 可重载

• this关键字的三种用法

super关键字用来访问父类内容，而this关键字用来访问本类内容

1.在本类的成员方法中，访问本类的成员变量

1

this.num // 本类中的成员变量

2.在本类的成员方法中，访问本类的另一个成员方法

1

this.method() // 本类的另一个成员方法

3.在本类的构造方法中，访问本类的另一个构造方法

1

this() // 访问本类的另一个构造方法，可重载，必须是构造方法的第一个语句

​ 使用场景

对于已经投入使用的类，尽量不要进行修改。推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容

• Java继承的特点

1.java语言是单继承的

一个类的直接父类只能有唯一一个

2.java语言可以多级继承

java.lang.Object是祖宗类

3.一个子类的直接父类是唯一的，但是一个父类可以有很多个子类

• 注意事项

1.必须包装方法的名称相同，参数列表也相同，@Override写在方法前，用来检测是不是有效的正确覆盖重写

2.子类方法的返回值必须小于等于父类方法的返回值范围，Object类是所有类的公共最高父类

java.lang.String就是Object的子类

3.子类方法的权限必须大于等于父类方法的权限修饰符，public > protected > (default) > private

(default)不是关键字default，而是什么都不写，留空

4.无论成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类

5.super和this两种方法构造调用，不能同时使用

多态

• 概述

extends继承或者implements接口实现，是多态的前提

一个对象拥有多种形态就是对象的多态性

• 多态的格式和使用

代码中体现多态性：父类引用指向子类对象

1
2

父类名称 对象名 = new 子类名称();
接口名称 对象名 = new 实现类名称();

访问成员变量

直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找

间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找

多态中成员方法

new谁则优先用谁，没有则向上找

编译看左边，运行看右边

用处(好处)

无论右边new的时候换成哪个子类对象，等号左边的调用方法都不会变化

对象的上下转型

​ 向上转型

1

父类名称 对象名 = new 子类名称();

右侧创建一个子类对象，把它当作父类看待使用

向上转型一定是安全的 从小范围转为大范围

弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容

​ 向下转型(还原)

1

子类名称 对象名 = (子类名称) 父类对象;

将父类对象还原为子类对象

必须保证对象本来创建的时候，就是猫，才能向下转型成为猫

如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错

​ 判断前面的对象能不能当后面类型的实例

1
2
3
4

对象 instanceof 类名称 // 将得到一个boolean值，可以判断前面的对象能不能当后面类型的实例
    if(animal instanceof Dog){
        Dog dog = (Dog) animal;
    }

匿名对象：

只有右边的对象，无左边的名字和赋值运算符

1
2
3
4

Scanner sc = new Scanner(System.in)
int num = sc.nextInt(); // 普通使用方式
int num = new Scanner(System.in).nextInt(); // 匿名对象的方式
methodParam(new Scanner(System.in)); // 使用匿名对象来传递参数

​ 注意事项：

匿名对象只能使用唯一的一次，下次使用要再创建一个新对象

​ 使用建议：

若确定一个对象只需要使用唯一的一次，就可以用匿名对象

静态static关键字

​ 1.一旦使用static关键字这样的内容不再属于对象而是属于类，凡是本类的对象都都共享同一份

​ 2.一旦使用static修饰成员方法，那么这就成了静态方法，静态方法不属于对象，而是属于类

​ 3.若没有static关键字，那么必须首先创建对象，然后通过对象才能使用它

1
2
3
4

Student obj = new Student();
obj.method(); // 没有static关键字，先创建
obj.methodStatic(); // 正确，但不推荐，编译后会被Javac翻译为；类名称.静态方法名
Student.methodStatic(); // 正确且推荐

​ 4.静态不能直接访问非静态(内存中先有的静态内容，后有的非静态内容)

​ 5.静态方法不能用this关键字

静态代码块

1
2
3
4
5

public class 类名称{
	static{
		// 静态代码块内容
	}
} // 当第一次使用本类时，静态代码块执行唯一一次，执行优先于构造方法

用途

用来一次性的对静态成员变量进行赋值

final关键字

用于修饰类

1
2
3

public final class 类名称 {

}

被final修饰的类不能有任何子类(不能作为父类)

用于修饰方法

当final关键字来修饰一个方法的时候，这个方法就是最终方法，不能被覆盖重写

用于修饰局部变量

一旦使用final关键字来修饰局部变量，那么这个变量就不能进行更改

对于基本类型来说不可变是变量当中的数据不可改变

对于引用数据类型来说不可变是变量当中的地址值不可改变

用于修饰成员变量

对于成员变量来说，如果使用final关键字修饰那么这个变量也是不可变的

1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值
3. 必须包装类当中所有重载的构造方法，都最终会对final的成员变量进行赋值

四种权限修饰符

(default)并不是关键字default 而是根本不写

内部类

如果一个事物内部包含另一个事物那么这就是一个类内部包含另一个类

成员内部类

1
2
3
4
5
6

修饰符 class 外部类名称 {
	修饰符 class 内部类名称{
		// ...
	}
	// ...
}

内用外，随意访问；外用内，需要内部类对象

间接使用方式：在外部类的方法中，使用内部类；然后main只是调用外部类的方法

直接使用方式

1

外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

• 内部类的同名变量访问

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

// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer{
	int num = 10;
    public class Inner{
        int num = 20;
        public void methodInner(){
            int num = 30
            System.out.println(num); // 内部类方法的局部变量，就近原则
            System.out.println(this.num); // 内部类的成员变量
            Systrm.out.println(Outer.this.num); // 外部类的成员变量
        }
    }
}

• 局部内部类的定义

如果一个方法定义在一个方法内部的，那么这就是一个局部内部类

局部：只有当前所属方法才能使用它，出了这个方法外面就不能用了

1
2
3
4
5
6
7

修饰符 class 外部类名称{
	修饰符 返回值类型 外部类方法名称(){
		class 局部内部类名称{
			// ...
		}
	}
}

定义一个类的时候，权限符修饰规则：

1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

final问题

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final(变量不能值不能改变)

备注：从Java 8+开始只要局部变量事实不变，那么final关键字可以省略

原因：1.new出来的在堆中

​ 2.局部变量跟着方法走在栈内存中

​ 3.方法运行结束后，立刻出栈，局部变量消失

​ 4.new出来的对象会在堆当中持续存在，直到垃圾回收

匿名内部类

如果接口的实现类(或者父类的子类)只需要使用唯一的一次

那么在这种情况下可以省略掉该类的定义，改为使用匿名内部类

1
2
3

接口名称 对象名 = new 接口名称(){
	// 覆盖重写所有抽象方法
};

对格式“new 接口名称(){…}”的解析

​ 1.new代表创建对象的动作

​ 2.接口名称就是匿名内部类需要实现哪个接口

​ 3.{…}是匿名内部类的内容

注意事项

​ 1.匿名内部类在创建对象时只能使用唯一的一次

如果希望多次创建对象，而且类的内容一样，那么必须使用单独定义的实现类

​ 2.匿名对象在调用方法的时候只能使用唯一的一次

如果希望同一个对象调用多次方法，那么必须有对象名

​ 3.匿名内部类是省略了实现类/子类，但是匿名对象是省略了对象名称

抽象

• 抽象方法

如果父类当中的方法不确定如何{}方法体的实现，那么这种方法叫抽象方法(eg：图像周长)

在返回值类型前加上abstract并去掉大括号，直接分号结束

1

public abstract void eat(); // 抽象方法，代表吃，具体吃什么不确定

• 抽象类

抽象方法所在类，必须是抽象类才行，在class前加上abstract即可

1

public abstract class Animal // 抽象类，里面可以有普通的成员方法

• 抽象方法和抽象类的使用

1.不能直接创建new抽象类对象

2.必须用一个子类来继承抽象父类

3.子类必须覆盖重写抽象父类当中所有的抽象方法

覆盖重写(实现)：子类去掉抽象方法的abstract关键字，然后补上方法体大括号

4.创建子类对象进行使用

• 注意事项

1.抽象类不能创建对象，如果创建，编译无法通过而保持，只能创建其非抽象子类的对象

2.抽象类中可以有构造方法，是供子类创建对象时，初始化父类成员使用的

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定时抽象类

4.抽象类的子类，必须重写抽象父类的所有的抽象方法，否则编译无法通过而报错，除非该子类也是抽象类

接口

• 概述

接口就是多个类的公共规范

接口是一种引用数据类型。最重要的内容就是其中的抽象方法

• 定义格式

1
2
3

public interface 接口名称 {
		// 接口内容
}

接口内容可以包含：1.常量 2.抽象方法 3.默认方法 4.静态方法 5.私有方法

1.接口的抽象方法

定义

1
2
3
4

public abstract 返回值类型 方法名称(参数列表);
public 返回值类型 方法名称(参数列表);
abstract 返回值类型 方法名称(参数列表);
返回值类型 方法名称(参数列表); // 接口的抽象方法省略写法

1. 接口当中的抽象方法，修饰符必须是两个固定的关键字： public abstract
2. 这两个关键字修饰符可以选择性省略
3. 方法的三要素可以随意定义

使用

1. 接口不能直接使用，必须有一个实现类来实现该接口

1
2
3

public class 实现类名称 implements 接口名称{
 	// ...
}

2.接口的实现类必须覆盖重写(实现)接口中所有的抽象方法

覆盖重写(实现) 去掉abstract关键字，加上方法体大括号

3.创建实现类的对象，进行使用

4.注意：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个接口必须是抽象类

2.接口的默认方法

定义

1
2
3
4
5
6

public default 返回值类型 方法名称(参数列表){
 	// ...
} // 默认方法可以有方法体
default 返回值类型 方法名称(参数列表){ //接口的默认方法省略写法
    
}

1. 接口当中的默认方法，可以解决接口升级的问题

使用

1. 接口的默认方法，可以通过接口实现类对象，直接调用
2. 接口的默认方法，也可以通过接口实现类进行覆盖重写

3.接口的静态方法

定义

从Java 8开始接口中允许当中允许定义静态方法

1
2
3
4
5
6

public static 返回值类型 方法名称(参数列表){
  	// 方法体
}
static 返回值类型 方法名称(参数列表){ // 接口的静态方法省略写法
    
}

使用

1. 不能通过接口实现类的对象来调用接口当中的静态方法
2. 通过接口名称直接调用其中的静态方法

接口名称.静态方法名(参数);

4.接口的私有方法

定义

1. 普通私有方法，解决多个默认方法之间重复代码问题

1
2
3

private 返回值类型 方法名称(参数列表){
	  // 方法体
}

2.静态私有方法，解决多个静态方法之间重复代码问题

1
2
3

private static 返回值类型 方法名称(参数列表){
	  	// 方法体
}

5.接口常量

定义

接口中可以定义“成员变量”，但是必须使用 public static final 三个关键字进行修饰

从效果上来看，这其实就是接口的常量

1

public static final 数据类型 常量名称 = 数据值;

一旦使用final关键字进行修饰，说明不可改变

使用

1. 接口中的常量可省略 public static final关键字
2. 接口中的常量必须进行赋值
3. 接口中常量的名称使用完全大写的字母，用下划线进行分割

1

接口名称.常量名称

6.接口之间的多继承

1. 类与类之间是单继承的，直接父类只有一个
2. 类与接口之间是多实现的，一个类可以有多个接口
3. 接口与接口之间是多继承的
4. 多个父接口当中的抽象方法如果重复，没关系
5. 多个父类接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，且带default关键字

• 注意事项

1.接口没有静态代码块和构造方法

2.一个类的直接父类是唯一的，但一个类可以同时实现多个接口

1
2
3

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
	// 覆盖重写所有抽象方法
}

3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可

4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类

5.如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写

6.一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法

常量

何为常量：

程序运行期间固定不变的量。

常量的分类：

​ 1.字符串常量：用“ “引起来的部分，eg：”HelloWorld”（双引号中可为空）

​ 2.整型常量：数字，无小数点，eg：100，-200，0

​ 3.浮点数常量 : 数字，有小数点，eg：3.14，-56.00

​ 4.字符常量：用’’引起来的部分，eg：’A’,’B’,’泽’（双引号中不为空）（java中允许使用中文字符）

​ 5.布尔常量：仅两种true,false

​ 6.空常量：null，代表没有任何数据。

数据类型

基本数据类型

整数型 byte short int long

浮点型 float double (近似值而非精确值)

字符型 char

布尔型 boolean

注意事项：

1.数据范围与字节数不一定相关

2.浮点数当中默认类型是double。如果使用float类型，需要加上后缀F

3.整数中默认类型是int。如果一定要使用long类型，需要加上后缀L

引用数据类型

字符串，数组，类(Scanner)，接口，Lambda

• 使用步骤：

1.导包

1

import 包路径.类名称;

如果需要使用的目标类和当前类位于同一个包下，则可以省略导包语句不写

只有java.lang包下的内容不需要导包，其他都需要import语句

2.创建

1

类名称 对象名 = new 类名称

3.使用

1

对象名.成员方法名

数据类型转换

• 自动类型转换

特点：代码不需要特殊处理，自动完成

规则：数据范围从小到大

• 强制数类型转换：

特点：代码需要特殊格式处理，不能自动完成

格式：

1

范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的类型

注意事项：

1.强制类型转换不推荐使用，可能发生精度损失和数据溢出

1
2

int num = (int) 6000000000L;
System.out.println(num);// 1705032704

2.byte/short/char类型都可以发生数学运算

1
2

char zifu = 'A';
System.out.println(zifu + 1);// 66

3.byte/short/char类型运算时，首先提升成为int类型，再计算

4.Boolean类型不能发生数据类型转换

ASCII表：

变量

何为变量：

​ 程序运行期间，可以改变的量

注意事项：

​ 1.如果创建多个变量，那么变量之间的名称不可以重复

​ 2.对于float和long类型来说字母后缀F和L不要丢掉

​ 3.如果使用byte和short类型的变量，右侧数据值范围不能超过左侧类型的范围

​ 4.变量需要先赋值才能使用

​ 5.变量使用不能超过作用域的范围

成员变量与局部变量的区别

​ 1.定义的位置不一样

​ 局部变量：在方法内部

​ 成员变量：在方法外部，直接写在类中

​ 2.作用范围不一样

​ 局部变量：只有在方法中才可使用

​ 成员变量：整个类通用

​ 3.默认值不一样

​ 局部变量：没有默认值，使用必须赋值

​ 成员变量：有初始默认值(与数组一样)

1
2
3
4
5
6

public class main {
    String name; // 成员变量
    public static void main(String[] args) {
      int num = 10; // 局部变量
    }
}

​ 4.内存的位置不一样

​ 局部变量：位于栈内存，随方法进栈而诞生，随方法出栈而消失

​ 成员变量：位于堆内存，随对象创建而诞生，随对象被垃圾回收而消失

类

定义类

1. 成员变量是直接定义在类中，在方法外面
2. 成员方法不要写static关键字

对象的创建及其使用

​ 通常情况下，一个类不能直接使用，需要创建一个对象才能使用

• 导包：指出所需要的类在什么位置

  1	import 包名称.类名称;

  ​ 对于和当前类属于同一个包的情况，可以省略导包语句不写

• 创建

  1	类名称 对象名 = new 类名称();

• 使用

  • 使用成员变量：对象名.成员变量名
  • 使用成员方法：对象名.成员方法名()

  注意事项：如果成员变量没有赋值会有一个初始值，规则和数组一样

类与对象的关系

• 类是对一类事物的描述，是抽象的
• 对象是一类对象的实例，是具体的
• 类是对象的模板，对象是类的实例

定义标准类：

• 组成部分

  1.所有成员变量都要使用private关键字修饰

  2.为每一个成员变量编写一对儿Getter/Setter方法

  3.编写一个无参数构造方法

  4.编写一个全参数构造方法

方法

• 何为方法：

将一个功能抽取出来，定义在一个大括号内，形成一个单独的功能。需要这个功能时，进行调用，实现了代码的复用性。

• 定义格式：

1
2
3
4

修饰符 返回值类型 方法名称 （参数类型 参数名称,...）{
	方法体
	return 返回值;
}

• return

1.停止当前方法

2.将后面的返回值还给调用处

3.return后面的返回值要与 返回值类型 保持一致

4.对于有返回值的方法，可以使用单独调用，打印调用和赋值调用

5.对于无返回值的方法，只能进行单独调用

6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己

7.无返回值，对于方法当中最后一行的return可以省略不写

8.一个方法中可以有多个return语句，但是必须保证同时只有一个会被执行

• 注意事项：

1.方法定义的先后顺序无所谓

2.方法定义不能产生嵌套包含关系

3.方法执行需要调用

• 调用格式：

1
2
3

方法名称（参数）;
System.out.println(方法名称（参数）)
数据类型 变量名称 = 方法名称（参数）

重载（OverLoad）

多个方法的名称一样，但参数列表不一样

方法重载相关因素：

1.参数个数

2.参数类型

3.参数的多类型顺序

方法重载无关因素：

1.参数名称

2.方法的返回值类型

构造方法

构造方法是专门用来创建对象的方法，当通过关键字new来创建对象时，其实就是再调用构造方法

创建格式：

1
2
3

public 类名称(参数类型 参数名称){
方法体
}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样

2.构造方法不要写任何返回值类型，包括void

3.构造方法不能return一个具体返回值

4.如果没有编写任何构造方法，编译器默认编一个构造方法，无参数、方法体

一旦编写，方法体不再赠送构造方法

5.构造方法可以进行重载(方法名称相同，参数列表不同)

数组

可以同时存放多个数据值

• 特点：

1.数组是一种引用数据类型

2.数据当中的多个数据，类型必须统一

3.数组的长度在程序运行期间不能改变

• 初始化方式：

1.动态初始化（指定长度）

1

数据类型[] 数组名称 = new 数据类型[数组长度];

2.静态初始化（指定内容）

1
2

数据类型[] 数组名称 = new 数据类型[] {元素1,元素2..};
数据类型[] 数组名称 = {元素1,元素2..};

• 注意事项

1.有new可以拆分成两个步骤

1
2

int[] array;
array = new int[] {11,23,21};

2.静态初始化省略格式不能拆分成两个步骤

3.若不确定数组当中的具体内容，用动态初始化，反之则用静态初始化

• 使用数组中的元素

1.直接打印数组名称，得到的是数组对应的内存地址哈希值

2.访问数组元素的格式 数组名称[索引值]（从0开始）

3.使用动态初始化数组时，其中的元素会自动拥有一个默认值

如果为整数类型，默认值为0

如果为浮点类型，默认值为0.0

如果为字符类型，默认为‘\u0000’

如果为布尔类型，默认为false

如果为引用类型，默认为null

• 数组异常

数组索引越界异常

空指针异常(没new创建)

• 获取数组的长度

1

int xxx = 数组名称.length;

1. 得到一个int数字，代表数组的长度

2. 数组一旦创建，程序运行期间长度不可改变

   1 2 3 4 5

   eg： int[] array = new int[3]; System.out.println(array.length);//3 array = new int[5]; System.out.println(array.length);//5

• 数组的遍历输出

  • 概念：对数组中的每个元素进行逐一处理(使用循环与数组长度)

  1 2 3 4

  for (int i = 0; i < 数组名.length; i++) { } //快捷码：数组名.length.fori

  数组作为方法的参数时，传递进去的是数组的地址

数组作为方法的返回值时，返回的是数组地址

语句

判断语句

单if

1
2
3

if(关系表达式){
     语句体;
}

if - - else

1
2
3
4
5

if(关系表达式) {
	语句体1;
}else{
	语句体2;
}

多if - - else

1
2
3
4
5
6
7
8
9
10
11

if (判断条件1) {
	执行语句1;
} else if (判断条件2){
	执行语句2;
} 
...
} else if (判断条件n) {
	执行语句n;
} else {
	执行语句n+1;
}

选择语句

switch语句格式

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

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

switch注意事项

1.多个case后面的数值不可以重复

2.swich后面的小括号中只能是：

基本数据类型：byte/short/char/int

引用数据类型：String字符串，enum枚举

3.switch语句前后顺序可以颠倒，且break语句可以省略（匹配到case后从当前位置向下执行，直到遇到break或default）

循环语句

1.初始化语句：在循环开始最初执行，并且只能做唯一一次。

2.条件判断：若成立，循环继续；反之则跳出循环。

3.循环体：重复要做的事情内容，若干行语句。

4.布进语句：每次循环之后的扫尾工作。

for循环

1
2
3

for (初始表达式; 布尔表达式; 步进表达式){
	循环体；
}

while循环

while格式

1
2
3
4
5

初始化语句;
while (条件判断){
	循环体;
	步进语句;
}

do - - while 循环

do - - while 格式

1
2
3
4
5

初始化语句
do {
	循环体
    步进语句
} while (条件判断);

三种循环的区别

1.若条件判断从未满足，for和while循环执行0次，do-while循环至少执行一次

2.for循环的变量在小括号中定义，仅能在循环中使用。while循环和do-while循环初始化语句在括号外，循环结束后可以继续使用

3.凡是次数确定的场景多用for循环，否则用while循环

break关键字

1.可以用在switch语句中，一旦执行，整个switch语句立刻结束

2.可以用在循环语句中，一旦执行，整个循环语句立刻结束，打断循环

continue关键字

1.一旦执行，立刻跳过当前次循环内容，马上开始下一次循环

JAVA的内存划分

1**.栈(Stack)：存放方法中的局部变量，运行方法一定要在栈中**

​ 局部变量：{}内的变量，一旦超出作用域，立刻从栈内存中消失

2.堆(Heap)：new出来的，在堆内存

​ 堆内存里的东西都有一个地址值：16进制

​ 堆内存里面的数据，都有默认值：

​ 若为整数 默认为0

​ 若为浮点数 默认为0.0

​ 若为字符 默认为‘\u0000’

​ 若为布尔 默认为false

​ 若为引用类型 默认为null

3.方法区(Method Area)：存储.class相关信息，包含方法的信息

4.本地方法栈(Native Method Stack)：与操作系统相关

5.寄存器(pc Register)：与CPU相关

API(Application Programming Interface)

概述:Java API程序员小词典

Scanner类

• 何为Scanner类

可以解析基本类型和字符串的简单文本扫描器(实现键盘输入到程序中)

• Scanner的一般步骤

1.导包

2.创建

1

Scanner sc = new Scanner(System.in);

​ System.in(键盘输入)

3.使用

1
2
3

对象名.成员方法名
int num = sc.nextInt(); // 获取键盘输入的一个int数字
String str = sc.next(); // 获取键盘输入的一个字符串

Random类

• 何为Random类：

用于生成随机数字的包

• Random的一般步骤：

1.导包

1

import java.util.Random

2.创建

1

Random r = new Random();

3.使用

1
2
3

int num = r.nextInt(); // 获取一个随机的int数字,有正负两种
int num = r.nextInt(3); // 获取一个随机的int数字(参数代表范围，左闭右开区间) 范围为[0,3)
int num = r.nextInt(n)+1; // 取值范围为[1,n]

ArrayList类

• 何为ArrayList类

可以实现数组的大小可变，操作内部的储存

表示泛型(装在集合当中的所有元素，全部都是统一的类型(引用类型而非基础类型))

• ArrayList的一般步骤

1.导包

1

import java.util.ArrayList;

2.创建

从JDK1.7+开始，右侧的尖括号内部可以不写写内容，但<>本身还是要写的

1

ArrayList<数据类型> list = new Arraylist<>();

3.使用

​ 1.向集合中添加元素: add

1
2
3
4
5

list.add("张三");
list.add("赵四"); // 向集合里添加一些数据
System.out.println(list); // [张三，赵四]
boolean success = list.add("王五");
System.out.println("添加的动作是否成功："+ success); // 添加的动作是否成功：true

​ 2.从集合中获取元素：get

1
2

String name = list.get(1); // 索引值从0开始
System.out.println("第一号索引位置："+ name); // 第一号索引位置：赵四

​ 3.从集合中删除元素：remove

1
2
3

String whoremove = list.remove(1); // 返回值是被删除的人
System.out.println("被删除的人是：" + whoremove); // 赵四
System.out.println(list); // [张三, 王五]

​ 4.获取集合的元素个数：size

1
2

int size = list.size();
System.out.println(size); // 2

5.遍历集合

1
2
3

for (int i = 0; i < list.size(); i++) {
           System.out.println(list.get(i));
       } // 快捷键 list.fori

​ 6.ArrayList集合存储基本数据类型、

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的包装类

包装类：引用类型，包装类都位于java.lang包下，不需要导包

1
2
3

ArrayList<Integer> listA = new ArrayList;
listA.add(100);
System.out.println(listA.get(0)); // 100

从JDK1.5开始，支持自动装箱，自动拆箱

​ 自动装箱：基本类型–>包装类型

​ 自动拆箱：包装类型–>基本类型

• ArrayList注意事项

对于ArrayList来说，直接打印得到的不是地址值，而是内容，若内容为空得到的时：[ ]

String类

• 概述

Java程序中所有字符串字面值(如“abc”)都作为此类的实例实现

• String类的一般步骤

1.特点

​ 1.字符串是常量，内容永不可变

​ 2.字符串可共享使用

​ 3.字符串效果相当于是char[ ]字符数组，但是底层原理是byte[ ]字节数组

​ 4.在java.lang.String包下不用导包

2.创建

常见3+1种方式

​ 三种构造方法：

1
2
3

public String() // 创建一个空白字符串，不含有任何内容
public String(char[] array) // 根据字符数组的内容，来创建对象的字符串
public String(bytr[] array) //根据字节数组的内容，来创建对应的字符串

​ 一种直接创建：

1

String str = "Hello"; // 右边直接用

3.使用

​ 1.字符串内容的比较( 直接==是进行对象的地址值比较)

1
2
3
4
5
6
7
8
9

public boolean equals(Object obj); // 任何对象都能用Object进行接受
public boolean equalsIgnoreCase(Object obj); // 忽略大小写
String str1 = "Hello";
char[] charArray = {'H','e','l','l','o'};
String str2 = new String(charArray);
System.out.println(str1.equals(str2)); // true
System.out.println(str2.equals("Hello")); // true
System.out.printlb("Hello".equals(str1)); // true
// 推荐："abc".equals(str)  不推荐：str.equals("abc")  原因是容易发生空指针异常

​ 2.字符串获取相关

1
2
3
4

public int length() // 获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str) // 将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index) // 获取指定索引(从零开始)位置的单个字符 如果没有返回-1
public int indexOf(String str) // 查找字符串在本字符串当中首次出现的索引位置

​ 3.字符串截取

1
2

public String substring(int index) // 截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin,int end) // 截取从begin开始到end结束中间的字符串  [begin,end)    

​ 4.相关转换

1
2
3

public char[] toCharArray() // 将当前字符串拆分成为单个字符数组作为返回值
public byte[] getBytes() // 获得当前字符串底层的字节数组
public String replace(CharSequence oldString,CharSequence newString) // 将所有出现的老字符串替换成为新的字符串，返回替换之后的新字符串

​ 5.字符串分割

1
2

public String[] split(String regex) // 按照参数的规则，将字符串切分成为若干部分
    //注意事项：split方法的参数是"正则表达式"，若按照英文句点"."进行切分，必须写"\\."(l)

• 注意事项：

1.对于引用数据类型来说， ==比较的是地址值

2.双引号直接写的字符串在常量池种，new不在池中

Arrays类

• 概述

提供一些与数组相关的工具类，提供了大量静态方法，用来实现数组常见的操作(静态方法不用new，直接类名称.方法名)

• Arrays使用

1
2
3
4
5

public static String toString(数组) // 将参数数组变成字符串(按照默认格式：[元素1, 元素2, ...])
public static void sort(数组) // 按照默认升序(从小到大)对数组进行排序
    /* 1.如果是数值，sort默认按照升序从小到大
       2.如果是字符串，sort默认按照字母升序
       3.如果是自定义类型，那么这个自定义的类需要有Comparable或Comparator接口的支持 */

Math类

• 概述

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算线管的操作，多为静态方法。

• Math类使用

1
2
3
4
5

public static double abs(double num) // 获取绝对值
public static double ceil(double num) // 向上取整
public static double floor(double num) // 向下取整[非四舍五入]
public static long round(double num) // 四舍五入
    Math.PI // d

• 注意事项

IDEA常用快捷键

IDEA常用快捷代码

一些小细节

1. & 称为逻辑与，只有两个操作数都是true，结果才是true。

   && 称为简洁与或者短路与，也是只有两个操作数都是true，结果才是true。但是如果左边操作数为false，就不计算右边的表达式，直接得出false。类似于短路了右边。

2. | 称为逻辑或，只有两个操作数都是false，结果才是false。

   || 称为简洁或或者短路或，也是只有两个操作数都是false，结果才是false。但是如果左边操作数为true，就不计算右边的表达式，直接得出true。类似于短路了右边。

更新于：Jun 24, 2021

JAVA