方法

1
2
3
4
5
// 定义方法的格式
修饰符	返回值类型	方法名称(参数类型 参数名称，....){
	方法体;
	return 返回值;
}

修饰符：现阶段的固定方法，public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据对应的变量名称
方法体：方法需要做的事情，若干行代码
return：两个作用。
- 停止当前方法
- 将后面的结果数据返回值返还给调用处
返回值：也就是方法执行后最终产生的数据结果

return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应

注意事项

方法应该定义在类中，但是不能在方法在定义方法。不能嵌套
方法定义的前后顺序无所谓
方法定义之后不会执行，若要执行，必须调用：单独调用，打印调用，赋值调用
如果方法有返回值，那么必须写上“return 返回值”，不能缺失
return后面的返回值类型必须和方法的返回值类型相同，对应。
对于一个void没有返回值的方法，没有返回值。
一个方法中可以含有多个return语句，但是必须保证同时只有一个会被执行到。

方法重载

多个方法的名称一样，但是参数列表不一样
优点：只需要记住唯一一个方法名称，就可以实现类似的多个功能

无关因素

与参数的名称无关
与方法的返回值类型无关

数组

数组的概念：是一种容器，可以同时存放多个数据值。数组的特点：

1.数组是一种引用数据类型
2.数组当中的多个数据，类型必须统一
3.数组的长度在程序运行期间不可改变

数组声明

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。两种常见的初始化方式：
1.动态初始化（指定长度）
2.静态初始化（指定内容）

动态初始化数组的格式：

声明格式：数据类型[]数组名称=new数据类型[数组长度]；

静态初始化数组的格式：

声明格式(标准)：数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，...}
省略格式：数据类型[] 数组名称 = {元素1，元素2，...}

注意事项： 1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
2.静态初始化标准格式可以拆分成为两个步骤。
3.动态初始化也可以拆分成为两个步骤。
4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化

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

规则如下：

如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符类型，那么默认为'\u0000'
如果是布尔类型，那么默认为false
如果是引用类型，那么默认为null

静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
数组的长度一旦创建，程序运行期间，长度不可变

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相关。

一个数组的内存图

所有的引用类型变量，都可以赋值为一个null值。代表其中什么都没有。

面向对象

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

类的定义

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物
属性：就是该事物的状态信息
行为：就是该事物能做什么

一个类的对象的内存图

使用对象类型作为方法的参数

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

1.定义的位置不一样【重点】
- 局部变量：在方法的内部
- 成员变量：在方法的外部，直接写在类当中
2.作用范围不一样【重点】
- 局部变量：只有方法当中才可以使用，出了方法就不能再用
- 成员变量：整个类全都可以通用。
3.默认值不一样【重点】
- 局部变量：没有默认值，如果要想使用，必须手动进行赋值
- 成员变量：如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样（了解）
- 局部变量：位于栈内存
- 成员变量：位于堆内存
5.生命周期不一样（了解）
- 局部变量：随着方法进栈而诞生，随着方法出栈而消失
- 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

面向对象三大特征：封装，继承，多态

封装性在Java当中的体现：

1.方法就是一种封装
2.关键字private也是一种封装封装就是将一些细节信息隐藏起来，对于外界不可见。

private关键字的作用

一旦使用了private关键字修饰，在同一个类中可以访问。但是其他类别不能直接访问

间接访问

定义一对Getter/Setter方法
必须叫setXxx或者是getxxx[如果是布尔值（那么用isXXX的命名会泽）]命名规则。
- 对于Getter来说，不能有参数，返回值类型和成员变量对应；
- 对于setter来说，不能有返回值，参数类型和成员变量对应。

This关键字的作用

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量
如果要访问类的成员变量需要用关键字：This
- 格式This.成员变量名

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。格式：
1 2 3
public 类名称（参数类型参数名称）{ 方法体 }
注意事项： 1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
5.一旦编写了至少一个构造方法，那么编译器将不再赠送。
6.构造方法也是可以进行重载的。
- 重载：方法名称相同，参数列表不同。

 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
// java标准类
package object.oriented;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/6 10:50
 */
public class BaseStudent {
    private String name;
    private int age;
    private char sex;

    // 无参数的构造方法
    public BaseStudent() {
        System.out.println("我是一个无参数的构造方法");
    }

    // 全参数的构造方法
    public BaseStudent(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;

        System.out.println("我是一个全参数的构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

API笔记

引用类型的一般使用步骤：
1.导包
- import 包路径.类名称；
- 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
  只有java.lang包下的内容不需要导包，其他的包都需要import语句。
2.创建
- 类名称对象名 = new 类名称（）；
3.使用
- 对象名.成员方法名()

匿名对象

只有右边的对象，没有左边的名字和赋值运算符。
- new 类名称().属性名

 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
package object.oriented;

import java.util.Scanner;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/7 17:34
 */
public class AnonymousDemo {
    public static void main(String[] args) {
        // 匿名对象
        new Student().eat();

        // 匿名对象作为参数
//        methiordParam(new Scanner(System.in));

        // 匿名对象作为返回值
        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("您输入的是：" + num);
    }

    public static void methiordParam(Scanner sc) {
        int num = sc.nextInt();
        System.out.println("输入的是：" + num);
    }

    public static Scanner methodReturn() {

        return new Scanner(System.in);
    }

}

对象数组

任何数据类型都可以作为数组里面的存储元素。

数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变

ArrayList集合概述和使用

ArrayList集合的长度是可以随意变化的。
对于ArrayList来说，有一个尖括号<E>代表泛型。
- 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
- 注意：泛型只能是引用类型，不能是基本类型

常用的ArrayList方法：

public boolean add（E e）：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但是对于其他集合（今后学习）来说，add添加动作不一定成功。
public E get（int index）：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove（int index）：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size（）：获取集合的尺寸长度，返回值是集合中包含的元素个数。

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

基本类型	包装类（引用类型，包装类都位于java.lang包下）
short	Short
int	Integer【特殊】
long	Long
char	Character【特殊】
float	Float
double	Double
boolean	Boolean

从 JDK 1.5+ 开始，支持自动装箱、自动拆箱。
自动装箱：基本类型–>包装类型
自动拆箱：包装类型–>基本类型

字符串的概述和特点

字符串的特点：

1.字符串的内容永不可变（字符串是常量）。【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的。
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式。三种构造方法：

public String（）：创建一个空白字符串，不含有任何内容。
public String（char[] array）：根据字符数组的内容，来创建对应的字符串。
public String（byte[] array）：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
string str="Hello"； 右边直接用双引号

字符串常量池

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中

对于基本类型来说，==是进行数值的比较。

对于引用类型来说，==是进行[地址值]的比较。

内存划分：

常用的API方法

==是进行对象的地址值比较，如果需要字符串的内容比较，可以使用两个方法：

public boolean equals（Object obj）：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
注意事项：
- 1.任何对象都能用Object进行接收。
- 2.equals方法具有对称性，也就是a.equals（b）和b.equals（a）效果一样。
- 3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面。

推荐："abc".equals（str不推荐：str.equals（"abc"）

public boolean equalsIgnoreCase（String str）：忽略大小写，进行内容比较。

`static`关键字的介绍

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。

多个对象共享同一份数据。

`static`关键字修饰成员变量

 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
package luenci.staticclass;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/12 16:18
 * @info 学生类
 */
public class Student {
    private int id;
    private String name;
    private int age;
    static String room = "Java一班";
    private static int idCount = 0;


    public Student() {
        this.id = ++idCount;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }


    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCount;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static String getRoom() {
        return room;
    }

    public static void setRoom(String room) {
        Student.room = room;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
package luenci.staticclass;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/12 16:22
 * @info 实例化例子
 */
public class Demo1 {
    public static void main(String[] args) {

        Student stu1 = new Student("Luenci", 22);
        Student stu2 = new Student("Lynn", 22);

        System.out.println("学号：" + stu1.getId() + "姓名：" + stu1.getName() + "年龄：" + stu1.getAge() + "班级：" + Student.room);
        System.out.println("学号：" + stu2.getId() + "姓名：" + stu2.getName() + "年龄：" + stu2.getAge() + "班级：" + Student.room);
    }

}

`static`关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
- 静态变量：类名称.静态变量
- 静态方法：类名称.静态方法（）

 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
package luenci.staticclass;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/12 16:49
 * @info 自定义方法类
 */
public class myClass {
    int num;
    static int age;

    public void method() {
        System.out.println("普通的成员方法");
        System.out.println(num);
        System.out.println(age);
    }

    public static void methodStatic() {
        System.out.println("静态方法");
        // 错误访问
        /*System.out.println(num);*/
        System.out.println(age);
    }
}

 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
package luenci.staticclass;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/12 16:50
 * @info static关键字修饰方法
 */
public class Demo2 {
    public static void main(String[] args) {
        myClass obj = new myClass();
        // 普通成员方法 对象名.成员方法（）
        obj.method();

        // 静态方法 推荐用：类名称.静态方法（）调用
        myClass.methodStatic();

        // 在本类中调用自己的静态方法，可以省略类名称
        myMethod();

    }

    public static void myMethod(){
        System.out.println("自己的方法");
    }
}

注意事项： 1.静态不能直接访问非静态。原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。 “先人不知道后人，但是后人知道先人。” 2.静态方法当中不能用this关键字。原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

`static`内存图

静态代码块

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：
- 用来一次性地对静态成员变量进行赋值。

Arrays类常用方法

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。
public static String tostring（数组）：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]）
public static void sort（数组）：按照默认升序（从小到大）对数组的元素进行排序。

 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
package luenci.array;

import java.util.Arrays;

/**
 * @author Luenci
 * @version 1.0
 * @date 2019/12/12 17:25
 * @info Arrays类的常见的使用方法
 */
public class ArraysDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        String str = Arrays.toString(array);
        System.out.println(str);

        int[] array1 = {1,4,5,9,2,5,7,0};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));

        String[] array2 = {"aaa","ccc","bbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}
out
    [1, 2, 3, 4]
    [0, 1, 2, 4, 5, 5, 7, 9]
    [aaa, bbb, ccc]

备注：
1.如果是数值，sort默认按照升序从小到大排序
2.如果是字符串，sort默认按照字母升序
3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。

Math相关的类方法

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
public static double abs（double num）：获取绝对值。有多种重载。
public static double ceil（double num）：向上取整。
public static double floor（double num）：向下取整。
public static long round（double num）：四舍五入。

`final`关键字

final关键字代表最终、不可改变的。

常见四种用法

修饰类

当final关键字用来修饰一个类的时候，格式： public final class 类名称（//…}
含义：当前这个类不能有任何的子类。（太监类）
注意事项：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。（没法继承，没有儿子）

修饰方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式： 修饰符final 返回值类型方法名称（参数列表）（//方法体}
注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

修饰局部变量

一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
“一次赋值，终生不变”

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

修饰成员变量

由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

四种权限修饰符

类别 \ 关键字	public	protected	（default）默认	private
同一个类	YES	YES	YES	YES
同一个类	YES	YES	YES	NO
不同包子类	YES	YES	NO	NO
不同包非子类	YES	NO	NO	NO

注意事项：（default）并不是关键字“default”，而是根本不写。

内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。例如：身体和心脏的关系。又如：汽车和发动机的关系。
分类：
- 成员内部类
- 局部内部类（包含匿名内部类）

成员内部类

成员内部类的定义格式：

1
2
3
4
5
6
7
修饰符 class 外部类名称{ 
	修饰符 class 内部类名称{
		// …
	}

	// ...
}

注意：
- 内用外，随意访问
- 外用内，需要内部类对象
如何使用成员内部类：
1.间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2.直接方式，公式：
- 类名称对象名=new 类名称（）；
- 【外部类名称.内部类名称对象名=new外部类名称（）.new内部类名称（）；】

内部类同名变量的访问

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式：

1
2
3
4
5
6
7
修饰符 class 外部类名称{
    修饰符 返回值 类型外部类方法名称（参数列表）{
        class 局部内部类名称{
            //…
        }
    }
}

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：
1.new出来的对象在堆内存当中。
2.局部变量是跟着方法走的，在栈内存当中。
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：

1
2
3
接口名称 对象名 = new 接口名称（）{
		//覆盖重写所有抽象方法
}；

对格式“new 接口名称（）{..}”进行解析： 1.new表示创建对象的动作 2.接口名称就是匿名内部类需要实现哪个接口 3.{.…}这才是匿含内部类的内容
注意几点问题：
1.匿名内部类，在【创建对象】的时候，只能使用唯一一次。如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2.匿名对象，在【调用方法】的时候，只能调用唯一一次。如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】强调：匿名内部类和匿名对象不是一回事

注意事项

小节一下类的权限修饰符： public > protected >（default）> private定义一个类的时候，权限修饰符规则：
1.外部类：public/（default）
2.成员内部类：public/protected/（deffult）/private
3.局部内部类：什么都不能加

方法#

注意事项#

方法重载#

相关因素#

无关因素#

数组#

数组声明#

Java中的内存划分#

面向对象#

类的定义#

成员变量和局部变量的区别#

private关键字的作用#

This关键字的作用#

构造方法#

API笔记#

匿名对象#

对象数组#

ArrayList集合概述和使用#

字符串的概述和特点#

字符串常量池#

常用的API方法#

static关键字的介绍#

static关键字修饰成员变量#

static关键字修饰成员方法#

static内存图#

静态代码块#

Arrays类常用方法#

Math相关的类方法#

final关键字#

常见四种用法#

修饰类#

修饰方法#

修饰局部变量#

修饰成员变量#

四种权限修饰符#

内部类#

成员内部类#

局部内部类#

匿名内部类#

注意事项#

方法

注意事项

方法重载

相关因素

无关因素

数组

数组声明

Java中的内存划分

面向对象

类的定义

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

private关键字的作用

This关键字的作用

构造方法

API笔记

匿名对象

对象数组

ArrayList集合概述和使用

字符串的概述和特点

字符串常量池

常用的API方法

`static`关键字的介绍

`static`关键字修饰成员变量

`static`关键字修饰成员方法

`static`内存图

静态代码块

Arrays类常用方法

Math相关的类方法

`final`关键字

常见四种用法

修饰类

修饰方法

修饰局部变量

修饰成员变量

四种权限修饰符

内部类

成员内部类

局部内部类

匿名内部类

注意事项