Java已学部分知识梳理

Java已学部分知识梳理

类：一群对象特征的母版，包含属性和方法。

对象：类的实现。

文档注释：生成API帮助文档

/**
*@autho：程序作者
*@version：源代码版本
*@param：方法中指定参数
*@return：返回值
*/

标识符命名规则：

只能包含数字，字母，$，下划线_；

不能以数字开头；

不能是关键字。

数据类型：

1、基本数据类型：

数值型：byte,short,int,long

浮点型：float,double

字符型：char(单引号)

布尔型：boolean

2、引用数据类型：类，数组，接口

变量：

声明与赋值语法：数据类型 变量名 = 值 例如：int a = 1;

分类：

局部变量，类变量，实例变量

运算符：（）优先级最高，赋值运算符优先级最低

流程控制：

1、顺序结构

2、分支结构：

形式一：if…

形式二：if…else…

形式三：if…else if…else…

switch语句：在控制表达式中，只允许出现 byte、short、int、char四种基础数据类型，在JDK1.7以后，支持 String 类型的控制表达式。

switch (expression) {
case condition1 : {
statement;
break;
}
case condition2 : {
statement;
break;
}
default : {
statement;
break;
}

3、循环结构：

while循环：

初始化语句；
while（循环条件）{
循环体；
迭代语句
}

do…while循环：无论如何都会执行一次循环体内容。

初始化语句；
do {
循环体；
迭代语句

} while (循环条件)

for循环：一般用于已知循环次数的遍历

for(初始化语句;循环条件；迭代语句) {
循环体；
}

循环控制：

break：跳出循环

continue：跳过循环的一个迭代

数组：

静态初始化：int[] arr = new int[]{1,2,3}；

简写：int[] arr = {1,2,3}；

动态初始化：int[] arr = new int[3];

索引从0开始，arr.length获取数组长度

一般使用for循环或者foreach遍历

for (int i = 0; i < arrs3.length; i++) {
System.out.println(arrs3[i]);
}

for(int a : arrs3) {
System.out.println(a);
}

面向对象:

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

构造器可以有多个，分带参和无参

静态成员不可以访问非静态成员。

静态方法需要用类名调用。

构造对象：类类型 对象名 = new 构造器方法();

this 用于在类定义中，获取当前对象的属性，或者调用当前对象的方法。用 static 修饰的方法中是不能使用 this 关键字的。

面向对象的三大特性：封装，继承，多态。

封装：

隐藏类方法实现的细节，使用private私有化；

通过方法来访问，getter,setter方法。

package：类应应在包中

import：需要用非同一个包中的类时，需要导包

访问控制修饰符：

private：只能在当前类中被访问，一般用于对成员变量的修饰；

default：没有定义修饰符就是 default；

protected：可以在子类和本包中被访问，外部包不能被访问，在有一定业务意义的包中，可以定义类中成员变量是protected；

public：一般定义在方法或者一些常量中，用于外部接口的访问

类的继承：

Java中是单继承，每个子类只有一个直接父类。

[修饰符] class SubClass extends SuperClass {
}

在子类中包含与父类同方法签名的现象称为「方法重写（Override）」，有时也称为方法覆盖。我们可以说子类重写了父类的方法，也可以说子类覆盖了父类的方法。

super限定：

super的使用和this的使用很相似。

如果需要在子类中调用父类被覆盖的方法，可以使用super关键字。

调用父类的构造器：

super()必须出现在第一行，而且只能有一个；

如果没有显式的调用，那么会调用父类的没有参数的构造器，如果父类没有定义空参数的构造器，则此时会无法编译。

多态：

编译的类型是父类，运行时的类型是子类

强制类型转换

子类型 变量名 = （子类型）（多态变量）

包装类：

在使用基本数据类型的时候，对于类的成员变量都会有默认值，但是这个默认值其实在很多的时候是有意义的，而不能随便的设置值。如果使用包装类，则不会有初始化值，定义的为null。

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

从构造器创建

自动装箱创建

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

final修饰符：

如果修饰类：则该类不会被继承（一般在开发中很少使用）；

如果修饰成员变量：一旦给成员变量赋值后就不允许修改其值，一般用在对常量的定义中

方法的重载和重写：

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

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

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

抽象类：

abstract关键字

如果在一个类中定义了抽象方法，那么这个类就是抽象类；

抽象类是无法实例化的，只能作为父类被继承使用；

抽象类的构造器只能用于被实现的子类的构造器调用。

接口：都是抽象方法

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

接口的继承：

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

接口的使用：

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

接口和抽象类： <
b13a
br>
相同点：

都不能被实例化，位于继承树的顶端，是用于被其他类继承或者实现的；

都包含抽象方法，子类都必须要实现抽象方法；

不同点：

抽象类中可以定义普通方法，但是接口中都是抽象方法和静态变量；

在抽象类是可以定义静态方法的，接口中不能定义静态方法的；

在抽象中可以定义构造器的，但是在接口中是不存在构造器这个概念的；

一个类最多只能有一个直接的父类或者抽象类，但是可以有多个接口的实现。

集合框架：Collection,Map

区别数组：只能存储对象，长度可变。

Collection:存放元素

实现类ArrayList

插入元素：add()

遍历元素：for循环,foreach，迭代器其中需要删除 元素需要使用迭代器删除

Map:存放key-value值

实现类HashMap

插入：put()

遍历 Map 结构

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

1. 获取 key 集合：map.keySet()；

2. 遍历 Key 集合：iterator；

3. 获取 Value 值：get(key)；

Object类：

toString：直接打印对象调用该方法

hashCode()：返回该对象的哈希码值，内存地址。

String类：

构建方式：

String s1 = new String("hello");
char[] cs = {'h','e','l','l','o'};
String s2 = new String(cs);
String s3 = "hello";

常用方法：

charAt():索引处的字符

replace():：替换

split():：字符串根据出入的参数转化为数组

indexOf():：第一次出现某字符串或字符的索引

substring():：根据出入的参数取字符串

contains():：判断是否包含

StringBuffer类：

比String类拼接要快，创建：StringBuffer sb = new StringBuffer("");

Date类：

Date类型格式化，使用SimpleDateFormat类。

format():格式化Date类型

parse():解析类Date类型

Calendar类用于日期处理

setTime(date):Date类型转为Calendar类

getTime()：Calendar类转为Date类

add()：添加天数月份等；

set()：用于设置

异常处理：

try…catch…finally

throws：抛出异常

单例模式：一个类只有一个对象

私有化构造器，创建方法获取已定义的对象。

JDBC:

步骤：

1. 选择数据库：加载数据库驱动

2. 连接数据库

3. 创建数据库查询

4. 获取查询结果

5. 关闭查询和连接