java知识点总结构造器 语法： [修饰符] 类名([参数列表]) {}

什么是Java

Java可以理解为编程语言或者开发工具。

目的

Java 最终的目的是用于编写直接在机器上运行的程序。

Java 的运行原理

Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。

类和对象概念

类是一群对象的特征母版，对象是类的实现。

特征（类）包含的内容有：基本属性（属性）、行为（方法）

分隔符：

• 花括号 {}：定义代码块，逻辑上是一个整体，包括类的主体、方法体、静态代码块、条件和循环语句的执行体；
• 分号 ；：语句的结束，如果出现在一行中有几条语句，那么多条之间也要用 ; 隔开；
• 方括号[]：用于数组中；
• 圆括号 () ：在方法中声明形式参数，在调用方法的时候传入实际参数，表达式优先级定义；
• 空格：单个空格、Tab 键、Enter 键，空格的出现是不会影响程序运行的，但是良好的缩进，可以提高程序的可读性；
• 圆点 . ：用于类/对象与其成员之间的分隔，表示调用类/对象的属性或者方法。

基本数据类型

• 数值型

  • 整数型：byte(-128-127)、short(15次方)、int(31次方)、long(63次方)
  • 浮点型：float(38次方)、double(308次方)
  • 在实际开发中，我们一般使用 int、double

• 字符型

  • char：用单引号表示，Java 中使用16位的 Unicode 字符集作为编码方式，

  • 表示方式

    • 直接通过单个字符表示：'a'、‘9' 等；
    • 通过转义字符表示：'\t'、'\n'、'\r'、'\''；
    • 直接使用 unicode 表示：'\uxxxx'。

1. 在 Java 中是没有表现多个字符的基本数据类型的，但是在 Java 中提供了一个 String 类，去表现字符串。
2. 转义字符的使用：当你要打印无法列出的字符，比如换行符等等，要用转义字符，还有就是一些在字符串内要搞错的字符，总之是对编译器来说具有特殊意义的字符。

• 布尔型

  • boolean：表示逻辑中的真和假，值只有 true / false。

在基本数据中，是可以进行类型之间的强制转化的，但是要注意，如果从低精度的转化为高精度时不会有问题，但是从高精度转化为低精度时，可能出现精度确实。

变量声明的语法：

数据类型 变量名;

例如：int a;

变量赋值的语法：

变量名 = 值;

例如：a = 10;

两者可以写在一起：

变量的生命周期

先记住：变量的生命周期在 {} 定义的范围内。

直接量

直接量是指在程序中直接通过源代码的方式指定的值，有时也成为字面量。

关于 String 类的特殊说明

String 类是一个不可改变类，意思就是在String 对象被创建出来后就不能被改变了。当程序第一次使用某个字符串直接量时，Java 会使用常量池来缓存该字符串直接量。如果后面程序用到了这个字符串直接量，Java 会直接引用常量池字符串。

在常量池中不会存在两个一样的字符串字面量值。

# 流程控制

• 顺序结构
• 判断（分支选择）结构
• 循环结构

数组的要点

• 存放的数据是相同的数据类型
• 数组的长度在定义时就确定了大小，数组是不可变长度的，或者说叫定长
• 数组中可以存放任意的数据类型（包含基本数据类型、引用数据类型、数组）
• 数组本身是引用数据类型（在栈内存中会存储其在堆内存中的引用地址）

定义语法

type[] 变量名; // 强烈建议用这种命名
type 变量名[]; // 只要知道就可以

数组的初始化

在 Java 语言中，数组必须先被初始化，才能被使用。所谓的初始化，就是在内存中为数组元素分配空间，并未每个元素赋予初始值。

• 静态初始化：显式的指定每个数组元素的值，由系统来决定数组的大小；
• 动态初始化：只需要指定数组的长度，通过程序动态的给每个元素赋值（即由系统为每个数组元素分配初始值）。

静态初始化

语法：

type[] arrayName = {element1, element2,....}; // 比较常见
type[] arrayName = new type[]{element1, element2,...};

类和对象

类： 是一种自定义的数据类型。有时把这种数据类型也叫做「类类型」或者「引用数据类型」。「引用」就是内存地址的意思。

对象：通过类创建的变量，或者叫类的实体。

方法

语法：

[修饰符] 方法的返回值数据类型 方法名(形参列表) {
    方法体语句;
}

• 修饰符：可以省略，也可以是 public protected private static final abstract，其中 public protected private 只允许出现一个
• 返回值：可以是数据类型（不要忘了自定义的数据类型），也可以是 void，如果定义了返回值，那么就必须在 return 后面跟随该类型的值或者对象。
• 方法名：一般首字母小写，也适用驼峰命名法则，一般是动词在前，名词在后，不易过长
• 形参列表：定义方法可以接受的参数，由 0-N 个 「数据类型 参数名」通过 「,」 组合的。一旦方法指定了形参，那么在调用的时候就必须一一对应的传入实参。

static 关键字

用于修饰成员变量和方法，用 static 修饰的成员变量后者方法是属于 类 的，而不属于该类的实例（对象）。通常把 static 修饰的成员变量称为「类变量、静态变量」，方法称为「类方法、静态方法」

静态的成员是不能访问非静态成员的；

静态成员之间是可以互相访问的。

类是一群对象的特征母版，对象是类的具体实例。

类是一群对象的抽象。

类的定义

类所具备的最基本要素：（静态）属性、（动态）方法。

语法：

[修饰符] class 类名 {
    // 成员变量
    [修饰符] 数据类型 成员变量1;
    [修饰符] 数据类型 成员变量2;
    ...

    // 方法
    [修饰符] 返回值 方法名1([参数列表]) {
        方法体语句;
    }
    [修饰符] 返回值 方法名2([参数列表]) {
        方法体语句;
    }
    ...

    // 构造器：创建对象用的方法
    [修饰符] 类名([参数列表1]) {
        方法语句;
    }
    [修饰符] 类名([参数列表2]) {
        方法语句;
    }

}

类的三大部件：成员变量、方法、构造器。

类名的定义要符合 Java 的标识符命名规范，类名首字母大写，如果多个单词，使用驼峰命名法则（每个独立单词首字母大写），在 Java 中，只要看到首字母大写，你就是一个类。

类中三大部件的定义是没有严格的顺序的，但是，我们一般遵循，构造器、成员编程、方法这样的定义顺序。

this 关键字

Java 中使用 this 关键字，指向调用该方法的对象。根据 this 所在的位置，大致分为两种：

• 出现在构造器中：引用该构造器正在初始化的对象；
• 普通方法中：调用该方法的对象。

this 用于在类定义中，获取当前对象的属性，或者调用当前对象的方法。

在类定义中，可以省略 this 关键字去调用属性或者方法，但是在类被编译的时候，编译器还是会加上 this 关键字。所以强烈建议在类定义时如果要调用该类中的普通成员变量或者方法，还是要把 this 加上去。

用 static 修饰的方法中是不能使用 this 关键字的。

封装的目的：

• 隐藏类方法实现的细节；
• 让使用者只能通过预先定义的方法来访问数据，从而可以在方法中加入一些控制逻辑，限制对成员变量的不合理访问。

Getter 和 Setter

把属性定义为 private 类型，即私有，向外部暴露其 get 和 set 方法。

相关方法名的定义：

• get + 首字母大写的属性名() ：get 方法一般都是具有和属性数据类型一致的返回值，并且是没有形参的。
• set + 首字母大写的属性名(参数)：set 方法一般都是具有和属性数据类型一致的方法参数，返回值一般是 void。

类的继承

继承是面向对象的三大特性之一，也是实现软件复用的重要手段。

Java中是单继承，每个子类只有一个直接父类。有的时候把父类也成为基类或者超类。

继承的特点

父类和子类是一种一般和特殊的关系。例如水果和苹果，苹果是一种特殊的水果。

子类能够继承父类的信息包括：

• 没有使用private修饰符修饰的成员变量和方法，子类都能够继承

• 子类重写了父类的方法，则父类的方法会被隐藏，隐藏的方法或者成员变量可以通过super关键字进行访问

• 引入super关键字的原因是可以访问被隐藏的成员变量和属性，而且super只能在子类的方法定义中使用。

多态

Java引用类型变量有两种类型：一种是编译时的类型，一种是运行时的类型。

• 编译的类型是由声明变量的时候决定的。

• 运行时类型由实际赋给该变量的对象决定。

如果运行时的类型和编译时的类型不一致就会出现所谓的多态。

• 首先编译时类型和运行时类型是一种父类和子类的关系。

• 多态最常用的场景就是子类重写父类的方法后，如果引用变量的类型为父类，而对象为子类，如果引用类型调用重写方法，会去执行子类定义的实现。

instanceof运算符

instance运算符的前一个操作数一般是引用数据类型变量，后一个操作数是类名（接口）,它是用于判断前面的对象是否是后面的类、或者其子类。如果是的话，返回true。

instanceof运算符一般用于在我们对引用数据类型进行强制类型转换之前判断使用。
避免在实际的运行过程中出现 ClassCastException

包装类中一般会提供两种构造器用于构建对象

• 使用基本数据类型的参数；

• 使用字符串类型的参数：对于此类参数，在实际创建对象的时候要注意输入的值要满足条件；

从基本数据转成引用数据的方法：

• 从构造器创建
• 自动装箱创建

从引用数据类型转成基本数据类型，使用 对象.xxxxValue();

		int y = 10;
		Integer yi = new Integer(y);
		Integer yi2 = y;

		int y3 = yi.intValue();

		boolean b = false;
		Boolean bi = new Boolean(b);
		Boolean bi2 = b;

		boolean bi3 = bi2.booleanValue();

在实际开发中，一般对于一个实体对象的类成员属性的定义，我们一般使用的是基本数据类型的包装类。

在使用基本数据类型的时候，对于类的成员变量都会有默认值，但是这个默认值其实在很多的时候是有意义的，而不能随便的设置值。

如果使用包装类，则不会有初始化值，定义的为null。

final 修饰符

final 修饰符

final 可以修饰在类、成员变量、方法

• 如果修饰类：则该类不会被继承（一般在开发中很少使用）；
• 如果修饰成员变量：一旦给成员变量赋值后就不允许修改其值，一般用在对常量的定义中。
• 如果修饰方法：该方法不能被重写

在实际的开发中， final 用的最多的场景是结合 static 关键字定义类变量，即静态变量。
定义为 final 另一个意图就是将变量的值保护起来。

方法的重载和重写

方法签名：只包含了方法名和参数列表

重写：发生在父类和子类之间，方法签名必须是一样的

重载：发生在本类中，方法名一样，但是参数列表不一样，重载可以是构造器的重载，也可以是方法的重载。

抽象方法和抽象类都是使用 abstract 修饰的

• 如果在一个类中定义了抽象方法，那么这个类就是抽象类；
• 抽象类是无法实例化的，只能作为父类被继承使用；
• 抽象类的构造器只能用于被实现的子类的构造器调用。

abstract 是不能修饰成员变量的；
如果方法定义为 static，就不能使用 abstract 修饰符；
如果方法定义为 private ，也不能使用 abstract 修饰符；

抽象类的作用

抽象类体现的是一种模板模式的设计思想，抽象类作为多个子类的通用模板，子类在抽象的基础上进行扩充，但是子类整体上会保留抽象类的行为方法（必须要实现抽象类的抽象方法）。

抽象类一般只是定义需要使用的方法，把不能实现的部分抽象成抽象方法，留给子类去实现。

父类中可以有实现的方法，但是子类也是可以对已经实现的方法进行改造的（override），但是如果在子类中还需要调用父类的实现方法，可以使用 super 关键字。

接口定义使用 interface 定义

语法：

[修饰符] interface 接口名 extends 父接口1, 父接口2... {
	0-N 个常量;
    0-N个抽象方法;
}

• 接口中所有的成员在定义的时候访问控制修饰符只能是 public 或者是 default；
• 接口的命名规范同类的命名规范；
• 在接口中，成员变量必须是静态的常量，方法必须是抽象方法，所以可以省略相关的修饰符。

接口的继承和类的继承不一样，接口支撑多继承，使用 extends 关键字，之间用逗号隔开，继承的内容包含了，常量和方法

须是该接口的实现类。

接口的作用：

• 用于定义实现类的行为规范；
• 定义变量
• 定义一些常量
• 被其他类实现

一个类是可以实现多个接口的，使用 implements 关键字，多个接口之间用逗号隔开。

一个完整的类定义的语法：

在一个 java 文件中，是可以定义多个类的，但是只允许有一个 public 类型的类存在。定义的 public 类型的类必须和文件名一致。

[修饰符：public、final] class 类名 extends 父类 implements 接口1,接口2...{
	....
}

在集合框架中，主要分为 Collection 和 Map 两大接口。
在 Collection 中又分为 List （有序集合） 和 Set （无序集合）。List 和 Set 都是接口。
Map 存储的 Key-Value 结构。

集合框架存储的元素可以是不定长的，即可以任意的添加，但是数组在定义的时候就确定了长度。实际开发中，对于同类型数据的结构，一般使用 Collection 结构会较多。

Collection

List

是实际开发中用的最多的一种数据结构，存储的单个元素，使用泛型去强制约束 List 中存放的是一致的数据类型

插入元素

add()

遍历元素

• 通过元素索引下标方式 for 循环
• 通过 foreach 循环
• 通过迭代器 Iterator

删除元素

如果通过遍历去查找相关元素进行删除的时候，不要使用 list.remove(int index) 该方法，因为使用该方法，会动态的直接改变集合的元素结构，导致遍历的不完整或者有错误。要使用迭代器遍历集合，调用 Iterator.remove() 方法删除。

Set

不详细阐述，在遍历的时候不能使用索引方式，只能通过迭代器和 foreach。

Map

类似的可以理解给集合元素中的值定义了一个 Key 键（遍历），之后可以通过相关的方法快速的定位到具体的 Value 中。

获取某个 key 的 value

Value get(Key)

如何遍历 Map 结构

获取 Map 的 Key 集合，通过遍历 Key 集合，获取 Value 值。

1. 获取 key 集合：map.keySet()；
2. 遍历 Key 集合：iterator；
3. 获取 Value 值：get(key)；

开发注意事项

在实际开发中，List 一般使用 ArrayList 实现类去构建，Map 一般使用 HashMap 实现类去构建。

要掌握对于 List 和 Map 的添加元素、遍历元素。

要认识集合框架中关于对象在内存中的存储方法。