java基础笔记，基础中的基础。对java开发小白有用

**

java基础笔记，基础中的基础。对java开发小白有用

**

j ava程序的最小组成单位是类（Class），一个源文件(.java) 中可以定义多个类
但是只能有一个public的类，并且要和源文件同名
类名一定要首字母大写，一定采用驼峰命名法

public static void main(String[] args){} 这句语句是固定的，main方法表示
java程序的主入口

java中声明变量需要指定变量的数据类型，这点和javascript由数据来决定类型不同
语法： 数据类型 变量名;

一，基本数据类型
数值类型
整型
byte 1字节 2^7-1
short 2字节 2^15-1
int 4字节 2^31-1
long 8字节 2^63-1 需要在值后面指定L
浮点型
float 4字节 单精度浮点型，最大7位精度 需要在值后面指定F
double 8字节 双精度浮点，最大16位精度
布尔类型
boolean 只有true和false
字符类型
char 0~65535 赋值用单引号 ‘A’

引用数据类型
字符串、数组、集合、对象等等

int 是基本数据类型 integer是包装类，当两者作为成员变量是，初始值分别为：int是0，integer是null，
其中integer提供了一些对整数操作的方法，还定义了integer型数值的最值，其他基本类型也有对应的包装类。
基本类型包装类的出现，使java完全面对对象
基本数据类型的包装类

基本类型	包装器类型
boolean	Boolean
char	Character
int	Integer
byte	Byte
short	Short
long	Long
float	Float
double	Double

二，运算符
算术运算 + - * / % ++ – （）
比较 > < >= <= ==
逻辑 && || !
三目 ？：

隐式类型转换：表达式类型小于赋值的目标类型会可以直接赋值
强制类型转换 ： 表达式类型大于目标类型需要强转，强转会丢失精度，需要使用
语法 (需要强转的类型)(表达式)

两个字符串之间进行比较内容相等的时候用equals ，字符串.equals(字符串)

三，数组
1.声明数组
数组的类型 [] 数组名;
2.开辟空间
数组名 = new 数组类型[长度];
3.使用
数组名[下标]

java数组的创建有三种方式
第一种
String[] names = new String[3];
第二种 new Array(3,5,7,9);
double[] scores = new double[]{3,5,7,9};
第三种
int [] arr = {1,3,5,7};

java数组长度不可变的
java数组开辟的空间的每个下标都有默认值：
基本类型数值型 (byte,short,char,int,long) 0 和 float = 0.0F double 0.0
boolean数组的默认是false

==和equals的区别
在比较引用类型的时候比较的是地址值
equals在未重写之前也是比的地址值，底层就是

栈：在方法运行期间产生的变量的句柄(变量名)和值存储在栈空间中.方法结束时栈中的变量会
GC回收

堆：所有通过new创建的对象（对象的空间，对象内的数据）都存储在堆中。然后把堆空间的地址
交给栈中的句柄引用。如果栈中多个句柄引用同一个地址，其中改变会影响所有正在使用的其他
句柄

String在比较==的时候分几种情况
1.如果两个字符串是直接赋值的那么这两个字符串一定相等，因为字面量存储在常量池中，
而相同的字面量会引用同一块内存
2.如果两个字符串是通过new出来的，或者其中一方是new的，那么一定不相等，因为new返回的
是堆地址值
3.给字符串赋值时用的是另一个变量加字面量相加也一定不相等，编译时不会得到
常量池中已存在的字符串的地址

类：由一组具有共同特征的事物抽象的一个概念，一个模版
对象：符合类的特征的一个具体存在的事物

类作用：用来描述一个事物，需要在类中去对这个事物的属性和方法进行定义
类在定义完成后不能直接使用类，而是应该根据类创建这个类的对象，可以理解为
（根据模子生产具体的东西）

使用对象
1.创建对象
类名 变量名(对象名) = new 类名() 这句话就表示根据这个类来创建对象,把创建出来的
对象交给一个变量，也可以称这个变量名为对象名

2.使用对象
对象名.属性 对象名.方法()

成员变量可以不用赋予初始值，默认的初始值，引用类型的默认值是null
基本类型和数组的下标相同

方法的定义:
访问修饰符 返回类型 方法名([参数列表]){
[return 返回值];
}
public : 表示公有
void : 表示无返回，如果方法需要返回需要指定返回类型
方法名自定义，避开关键字，采用驼峰命名规则，首字母必须小写

全局变量
1.声明在类中的成员属性也被称为全局变量
2.全局变量具有初始值，没有赋予初始值也能使用
3.全局变量在所有的方法内可用
4.全局变量和局部变量可以同名
局部变量
1.声明在方法内的变量为局部变量
2.局部变量要赋予初始值才能使用
3.局部变量只能在当前声明的方法内可以使用
4.在同一个方法内不能有两个变量同名，可以和全局变量同名，如果使用的变量
在全局和局部都声明，就近原则使用局部变量
如果要使用全局变量就使用this.变量名 this代表当前的对象

java方法中定义参数要定义参数的数据类型，多个参数用逗号隔开，调用带参方法
需要传递对应数目的实参，个数和类型一一对应
形参：形式参数，写在方法定义时的小括号内。接收调用时传递过来的实参
实参：调用带参方法时传递的数据
java的方法在传参时只有值传递，没有引用传递，基本类型传递的是数据，引用
类型传递的是地址值。而String因为是不可变类型无法被改变

Constructor 构造方法（构造器）
构造方法的作用：给类（对象）中的属性初始化

实例化：创建对象的实例，开辟对象的数据存储空间
初始化：给对象中的属性进行初始化的赋值

构造方法和普通方法的不同，构造方法不需要声明返回，并且方法名和类名相同
public 类名(){ }
构造方法不需要手动去调用，而是在我们创建对象编写: new 类名() 就是在调用
类的无参构造方法
重载
对于一种事物的不同表现形式被称为多态，重载是多态的体现之一
方法的重载，发生在同一个类中，可以有多个方法名相同，参数列表不同
（顺序，个数，类型）。这些方法就构成重载

方法重载后使用方法会根据调用时传递的实参自动匹配最佳可行的那个方法执行
如果没有完美匹配（虽然类型不完全匹配，但是满足自动类型转换规则），又
同时有多个可行

构造方法也可以重载
所有的java类在不写构造方法的时候都默认存在一个隐式的无参构造方法
如果编写带参的构造方法，默认的无参构造方法将不存在，如果需要要自定义

包（Package）
包相当于文件夹，用来管理类。包的命名具有意义的，通常包的命名都是由
组织的域名为前缀 + 自己的功能模块名称
在同一个包中使用本包下的类可以直接用，其他包中的类需要导包使用
import 包名.*; 可以使用整个包下的类
import 包名.类名; 只导入该包下的该类的引用

面向对象的三大特征 （封装、继承、多态）
封装:
通过把对象的属性私有化屏蔽对外部的直接访问，提高安全性。通过get
和set方法自定义实现赋值和取值的方式，屏蔽内部实现细节。
1.把对象中的属性私有化 ，在其他类中无法直接通过对象名.属性
2.getter/setter方法提供对属性的读和写的功能

static 关键字
静态关键字static，可以用来修饰内部类、属性、方法、代码块、导包

静态变量
1.被static修饰，可以直接通过类名.静态变量 来使用，而不需要通过对象来使用
2.被静态修饰的变量会在编译期间就存储在静态块（堆空间的一部分）
3.静态的变量修改会始终在同一个空间中改变，所以如果经常被修改的属性需要控制线程安全
4.静态变量能够被声明的类中的成员方法直接访问

静态方法
1.被static修饰的方法称为静态方法，和静态变量一样，静态方法可以通过类名直接.调用
2.静态方法中不可以使用this关键字，不可以直接访问成员变量，不能直接访问成员方法

静态代码块
被static修饰的{} ，和静态变量一样，会在编译期间就加载并且执行，和静态
变量的加载顺序按照编写顺序决定

类加载顺序
1.加载静态变量和静态代码块(由顺序决定)
2.成员变量
3.实例块
4.构造方法

简单的设计模式
1.单例模式 ： 一个类只能有一个实例。 有些类的对象是重量级的，过多的创建
会浪费资源
语法有四种：饿汉式、懒汉式、双重锁模式、枚举

继承：
面向对象特征之一.把多个类中共同的属性和方法提取到父类中。可以减少。咦克死登斯
重复代码，在各个子类中通过extends关键字继承这个父类。规则：
public class 子类名 extends 父类名 { }

特征：
1.子类继承父类之后就拥有父类一切非私有的属性和方法
2.java中类只能单继承，extends只能有一个类名，不能多继承，只能有一个直接父类
3.构造方法不能被继承
4.子类在实例化时会先实例化父类的对象
5.虽然只能单继承但是继承会有传递性，父类的父类中的方法能够被子类所继承使用
6.所有的类都默认继承Object。Object类也可以称为所有类的基类，超类

当存在父类时类的加载顺序
1.先加载父类的静态变量和静态代码块
2.子类的静态变量和静态代码块
3.创建父类的对象 ： 加载父类的变量、实例代码块执行、父类构造方法
4.子类对象的创建 ： 加载子类的变量、实例代码块执行、子类构造方法

this 关键字
this在类的方法中使用该关键字表示当前正在调用该方法的对象
this.当前对象的属性 （类的成员变量）
this.该类的成员方法()
this() 可以调用同类的构造方法 ，但是必须在本类的构造方法的第一行调用

super 关键字
super在类中代表的是父类对象
super.父类允许访问的属性
super.父类非私有的方法()
super() 调用父类的无参构造方法，在子类的无参构造方法的第一行存在一个隐式
的super() 调用父类的无参
super(参数。。。)
如果子类和父类中有同名的方法

this、super不能写在静态

重写：
重写发生父类和子类之间，方法名相同，参数列表相同，返回类型满足向上
转型，访问修饰符不能比父类的更加严谨，异常可以不抛，如果抛出异常不能比父类
的异常更大

重写是多态的表现形式之一，主要为了解决父类中的方法并不适用于所有子类
在子类重写了父类的方法后调用的就是子类自己重写后的方法
Object 类中定义了对象的比较方法equals
常用的类中重写了equals的有：String

Abstract 抽象：
该关键字可以用来修饰类、方法
修饰的类被称为抽象类，抽象类具有的特征
1.虽然有构造方法，但是无法主动去new来实例化
2.抽象类中可以定义普通方法，还可以定义抽象方法

抽象方法特征
1.由abstract修饰，不能有方法体
2.子类必须对父类的抽象方法进行重写，除非子类也是抽象类
3.抽象方法必须声明在抽象类中，或者接口中
抽象方法更像是父类对子类行为的一种约束，约束子类必须做什么

访问权限：public protected 默认（不写） private
本类 同包 子类 所有
private ✔
default ✔ ✔
protected ✔ ✔ ✔
public ✔ ✔ ✔ ✔

final关键字（终态）
final修饰类无法拥有子类，不能被继承
final修饰方法，方法无法被重写
final修饰属性被称为常量。常量不可变，只能赋值一次
常量命名必须全大写，不能用驼峰命名用下划线分割多个单词
常量如果是成员变量必须初始化 ，如果是局部变量只能有一句赋值语句
ps：值不可变指的是等号不能指向新的内容，包括对象不能指向新的地址

多态：同一种事物的不同表现形式 ，体现方式有重载和重写
语法:
1.父子类继承关系
2.子类必须重写父类的方法
3.父类的引用指向子类实例

这种写法我们也称为向上转型。这样就只能使用子类重写了的父类的方法以及父类
自己定义的属性和方法

多态的使用体现在参数的多态和返回的多态上

如果非要使用子类内定义的属性和方法我们需要向下转型,需要强转:
子类类型 变量名 = (强转成子类类型)父类的对象
可以使用 instanceof 关键字判断对象的原始类型：
对象 instanceof 类 ，返回一个布尔类型，用来判断该对象是不是某个类的对象

多态的优点
1.只需要关注需要关注的对象，知道的更少。屏蔽不同子类的实现
2.容易维护

接口 interface
接口不是类，它是一个纯抽象的，用于定义一种能力，但是本身不具备实现
1.所有的方法都是public abstract 修饰的,在java8支持static和default修饰
2.所有的变量都是静态常量，被public static final 修饰

接口还可以多继承其他接口，实现类实现一个接口就必须实现这个接口以及父接口
所有的抽象方法
一个类也可以同时实现多个接口，用逗号分割
类可以同时继承类和实现接口，要先写继承再写实现:
class 类 extends 父类 implements 接口名{}

面向接口编程的优点：松耦合，减少依赖，易于维护

集合：java中的数据存储结构

Collection 集合的顶层接口，不能被实例化的
1，List 该接口下的集合特征是有序，可重复的
a，ArrayList
i，底层使用动态数组实现（可变的数组）
ii，初始大小为10
iii，会自动扩容，在原来的基础上增长百分之50%
b，LinkedList
i，底层是双向链表
ii，查询效率比arrayList低，但是插入和删除比ArrayList效率更高
iii，提供了额外的对首尾的增删查操作
c，Vector
i，底层和ArrayList一样
ii，对元素的操作的方法都是同步的，性能低
2，Set 无序的，不可重复的
a，HashSet 无序，不可重复
i，底层是哈希表和链表实现，由hashCode和equals方法来判断重复
规则：先把准备插入的元素和集合中的元素进行hashCode比较
相等：则使用插入的元素和相等的元素进行equals比较，相等就认为重复
不等：则不重复，可以直接插入

两个对象的equals相等，那么这两个对象的hashCode一定相等
hashCode相等，equals可以不等