JavaSE基础全整合

本文整合JavaSE大部分基本知识（不敢说全部），如果你是Java初学者，可以参照这些知识点进行Java基础的学习，如果是你已经学习Java多年，不妨试着回忆一下这些基础。

程序基础

数据类型

引用类型

类；接口；数组。

基础类型

数值

整数

byte（-2的七次方~2的七次方-1）；
short（-2的十五次方~2的十五次方-1）；
int（-2的三十一次方~2的三十一次-1）；
long（-2的六十三次方~2的六十三次方-1）。

浮点

float（符号位是1bit；指数位是8bit；尾数位是23bit）公式：(−1)S∗(2E−127)∗(1.M)；
double（符号位是1bit；指数位是11bit；尾数位是52bit）公式：double(−1)S∗(2E−1023)∗(1.M)；

字符

char（16bit）。

布尔

boolean（8bit）。

变量

命名规则

大小写字母，数字，下划线，美元符号，数字不能打头。不能使用关键字和保留字；建议望文知义，驼峰命名法。

分类

静态变量

类体中用static修饰。

局部变量

方法体中声明的变量。

成员变量

类体中没有static修饰。

调用

静态

类名.变量名（或）变量名

成员

对象. 变量名

局部

变量名

优先级

方法中局部变量优先级大于静态和成员；使用类名变量和局部变量；使用this区分局部变量和成员变量；使用super区分父子类同名的属性。

运算符

++ - -

i++ 先赋值然后再++；++i先++再进行赋值。

三目

boolean表达式？真：假

字符串连接符

流程控制

顺序结构

从上往下，从左往右。

分支结构

if

单分支

if(){}

双分支

if(){}else{}

多分支

if(){}else if(){}
一个分支执行，整个流程控制结束。

switch

java1.7版本开始可以传入字符串和整数；分支应该加上break，防止case穿透。

循环结构

三要素

初始值；终止条件；步长。

for

计数循环；执行0~N次；
for(int i=0;i<10;i++){}

while

真假循环；执行0~N次；
while(boolean表达式){}

do…while

真假循环；执行1~N次；
do{}while(boolean表达式)

方法

目的

代码复用；简洁；易维护。

声明

修饰符 返回值类型 方法名（参数列表）{方法体}

分类

静态方法

类体中有static修饰。

成员方法

类体中没有static修饰。

构造方法

没有返回值，连void都没有，方法名和类名一致；如果没有定义构造方法，则默认有一个公共的无参构造。

重载

方法名相同；参数列表不同（个数不同；类型不同）。

递归

方法体内部调用当前方法；树状结构的可以使用递归，比如文件目录。

数组

数据结构

是计算机存储和组织数据的一种方式；合理选择数据结构可以提高效率。

特性

查询更改快，删除添加慢；数组一旦确定，长度不能更改，除非新建数组，然后把原数组中的元素复制进去，赋值的过程中，进行添加和删除；内存空间是连续的；下标从0开始；数组每一维的数据的类型必须一致。

声明

静态

知道没有元素的时候，使用静态；
数据类型[] 变量 = {值，值，值}
数据类型[] 变量 = new 数据类型[]{值，值，值}（方法调用，传递字面量数组，必须这样写）

动态

不知道每个元素值的时候，使用动态，但是要指定长度；
数据类型[] 变量 = new 数据类型[长度]

使用

查询

数组[下标]

更改

数组[下标] = 值

遍历

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

二维数组

声明

静态

数据类型[][] 变量 = {{}{}{}}

动态

数据类型[][] 变量 = new 数据类型[一维元素个数][一维中元素的个数]

使用

数组[下标][下标]
数组[下标][下标] = 值

遍历

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

排序

冒泡

相邻比较；每次把最大的放在后面。

选择

和后面所有比较，每次把最小的方在前面。

API

Arrays.sort(arr);

二分法

折半查询法，必须有序

原理

起始值，结束值，中间值;
使用中间值和要找的元素进行比较;
如果中间值大于目标数据则取前半截.·起始值不变，结束值=中间值-1，重新生成中间值;
如果中间值小于目标效据，则取后半截，起始值=中间值+1，结束值不变，重新生或中间值;
如果等于，直接return返回中间值;
如果起始值大于结束值，则终止循环，返回-1，说明没有找到。

编码

int target = 99;
int[] arr = {x,x,x,x};// 需要传入的参数
int start = 0;
int end = arr.length-1;
int m = (start+end)/2;
while(start <= end){
	if(arr[m]>target){
		end = m-1;
		m=(start+end)/2;
	}else if(arr[m]<target){
		start=m+1;
		m=(start+end)/2;
	}else{
	return m;
	}
}

面向对象

面向对象和面向过程

面向对象侧重于模块化分类；面向过程侧重于完成一件事的分步骤。

类和对象的区别

类

定义模板；根据属性定义变量；根据行为定义方法。

对象

符合模板的要求的一个具体实现；对象是个体；属性有具体的值。

对象的创建和使用

类类型：变量=new 类（）
变量.成员变量
变量.成员方法（）

静态和成员的应用场景

静态：所有对象共享；属性和值都相同。
动态：对象不共享；属性相同；值不同。

软件包机制

package

解决命名冲突的问题；
一般域名倒置，项目，模块。

import

导包；
使用其他类的时候，需要找到他，需要些对应的类的全名（包名.类名）；
太长，不美观，麻烦，可以使用import导入后，直接写类名使用；
注意不要导错包。

修饰符

权限控制；final。

继承

代码复用；class类 extends 父类名（）

多态

是什么

父类引用指向子类对象。

缺点

丢失子类特有属性。

优点

解耦；耦合度降低；应该依赖抽象而不依赖具体实现。

多种形式

直接多态

父类 变量 = new 子类（）

实参/形参

方法声明时，参数列表是父类，方法调用时传递子类对象；
public static void m1(Sup s){}
m1(new Sub());

返回值

返回值类型是父类类型，但是返回数据为子类对象。
public Sup m2(){return new Sub();}

隐式多态

通过子类对象调用父类方法的时候，此时父类方法中的上下文环境变成多态环境。

调用总结

父类没有，直接报错，调用不了；
父类有，子类没有，执行父类；
父类子类都有，除了成员方法执行子类，其他全部执行父类。

覆写

应用场景

父类功能无法满足子类需求的时候，需要进行重写。

规则

返回值，方法名；参数列表必须一致；
不能有宽泛的异常；
不能有耕地的访问权限。

this

成员变量；
保存在当前类对象的内存地址；
不能出现在静态环境中；
谁调用这个方法，this就指向谁。

用法

返回this可以链式调用 return this；
区分同名的成员变量和局部变量 this.age = age；
用在构造方法的第一行，重载调用当前类其他构造方法 this(xxxx)；

super

在子类中表示父类型特征；

用法

区分子类父类同名属性

super.age;
super.m1()

用在构造方法第一行，调用指定父类构造方法

super(xxx)
如果构造方法没有第一行没有super(xx)也没有this(xx)，则默认第一行默认super()调用父类无参构造。

Object

是什么

是Java提供的根类（祖宗）；
如果一个类没有显示，继承一个父类的话，则该类默认继承Object；
所有类都必须是Object的后代；
所以Object中的所有成员，是所有类都有的属性和行为。

equals

比较两个对象是否相等。

toString

返回该对象的字符串描述；
输出一个引用类型的变量是，会自动调用该对象的toString方法。

hashCode

生成唯一的hash值；
hash冲突，多个对象可能生成相同的hash值。

finalize

垃圾自动回收；
被回收之前，会调用调用该对象的finalize方法；
可以通过System.gc()建议回收。

Abstract

是什么

修饰符；
修饰的类，是抽象类，不能实例化；
修饰的成员方法，是抽象方法，没有方法体，需要子类覆写；
抽象方法必须在抽象类中；
抽象类中可以没有抽象方法；
抽象类一般用于被继承，而抽象方法只能用于被子类覆写；
如果一个非抽象类，继承一个抽象类，则必须实现所有的抽象方法；
如果一个抽象类，继承一个抽象类，则可以实现0~N个抽象方法；
Abstract和final不能同时出现。

怎么用

abstract class A{
	public abstract void move1();
	public abstract void move2();
	public void m1(){
		System.out.println("父类的m1");
	}
}
abstract class C extends A{
} 
class B extends A{
	@Override
	public void move1(){}
}