java基础知识回顾

Java基础知识回顾
javase java 标准版
javaee java 企业版
jvm Java虚拟机
jdk java程序运行的最小部件 =jvm+java核心类库
jre =开发工具（Java javac 等）+jdk
javac 将.java文件编译成.class字节码文件 java将字节码文件在jvm上运行
dos
创建文件夹：made directory 在当前目录下创建文件夹
删除文件目录：remove directory 只删出文件目录不删除文件中的内容
删除文件：del
清空命令行：cls
F3 赋值上一次的命令

java语言的基础组成部分
1.关键字：官方定义好的只能使用不能重新定义的单词 保留字：非官方的，不能在java中使用了，但是用户也不能重新定义
2.标识符：给java程序中类 变量 方法 标签等命名的单词
类的命名规范：可以使用字母 数字下划线 美元符号 等 不可以以数字开头 开头大写
方法的命名规范：首字母小写 每个单词的首字母大写：驼峰命名法
3.注释
多行注释：/*
*/
单行注释：//
文档注释：/**
*
*
*/
4：类
5：方法
7：变量
8：常量
整数 byte short int long
小数 float double
布尔 boolean
字符 char
null
字符串 String

整数：
二进制：binary 0-1
八进制：octal 0-7 必须以0开头以与二进制进行区分
十六进制：hex 0-9 A-F 以0x 开头
十进制：0-9

程序:计算机指令的集合 通过程序指令让计算机完成某个操作

数据类型分为：基本数据类型和引用数据类型（类 接口 数组）
封装：也就是把具体的事物变成类，并不允许直接访问，但是对可见部分提供访问方法，不允许访问不可见的部分
继承：提高代码的复用性
多态：既一个对象多种形态，一个对象既可以是父类（猫是动物） ,也是猫，子类的对象可以使用类的属性和方法。可以用一个父类的引用
指向子类对象
object是java中所有类的父类，也就是说所有类包括数组都是以object这个类为基础创造出来的。
接口是常量和抽象方法的集合，是一种特殊的抽象类，只包含常量和方法的定义没有实现。
与object没有关系，接口默认有equals、hashcode、toString、clone和finalize这5个方法

构造方法只有一个：object（）
object中的方法：
getClass 返回此类的运行时类
什么是运行时类：java程序状态分为编译和运行两种状态 例：person p=new female()
编译时会在先在栈中创建变量和类的引用，当运行程序的时候才会在堆中分配一个空间创造female对象
而运行时类是指在编译的时候，jvm并不清楚你具体是一个怎样的类，而是按照一个所有类通用的模版来储存类，也就是对所有类抽象的一个模版得出的类，他包含类的名字
锁 等信息。而运行时类也就是这个类的对象。

hashCode():返回对象的哈希值
equals():比较两个对象是否相同
toString:getClass().getName() + "@" + Integer.toHexString(hashCode()
clone:返回一个此对象的副本，也就是运行时类相同的另一个对象
finalize:垃圾回收器用于回收这个对象的方法
wait():是当前线程进入冷冻期
notify:唤醒一个线程
notifyAll:唤醒所有线程
基本数据类型：
类型 位数 最大存储量 范围
byte 8位 255 -128~127之间
short 16位 65536 -32768~32767之间
int 32位 2的32次方减1 负的2的31次方到正的2的31次方减1
long 64位 2的64次方减1 负的2的63次方到正的2的63次方减1
float 32位 3.4e-45~1.4e38 直接赋值时必须在数字后加上f或F
double 64位 4.9e-324~1.8e308 赋值时可以加d或D也可以不加
boolean 只有true和false两个取值
char 16位 存储Unicode码 用单引号赋值
Java决定了每种简单类型的大小。这些大小并不随着机器结构的变化而变化。 这种大小的不可更改正是Java程序具有很强移植能力的原因之一。
封装器类：

简单类型 boolean byte char short Int long float double void
二进制位数 1 8 16 16 32 64 32 64 –
封装器类 Boolean Byte Character Short Integer Long Float Double Void
浮点数是用二进制的形式存储在计算机中的，但是并不是所有的10进制小数都能够准确的转化为二进制。故2.0-1.1所得的结果为1.8999999999其结果并不准确，所以实际运算中要使用
用于运算的高精度类
Java基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象
所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

常量:static final 修饰 存储在方法区中 常量声明后一定要赋值 因为常量值不允许变动
static 静态的 也就是公共的，存储在方法区中，在对象创建之前就已经赋值，对于每个对象都是公共的。用于每个对象共有的数据
Java.lang包是默认导入每个java文件中的
编译java文件后会生成若干.class文件，其中被public修饰的类只有一个存放main函数，作为程序的入口。一个java文件中有多少类和接口就会生成多少.class文件

操作符
1.算数操作符 + — * % / %结果的符号有除数的符号决定 只能由基本数据类型使用、
2.关系操作符 〉 〈 〉= 〈= 返回boolean值 只有基本数据类型使用
3.逻辑操作符 == ！= 判断两个对象是否相等 && 11用于两个boolean型数据 存在短路 ！非 取相反的Boolean值
4.=赋值符号 把左边的赋给右边 但是左右两边类型相同 或左边是右边的父类
5.自增 自减符号
6.括号
7.按位操作符 操作bit 也可以操作boolean & 1 ~非 按位取反符 ^异或 一个数异或另一数两次还是那个数
8.移位操作符 〈〈逻辑左移 操作的单位是bit 左移几位就是乘以2的几次幂空位补0
〉〉逻辑右移若符号为正高位补0 若为负高位补1
〉〉〉无符号右移 无论正负高位补0
9.+ += string 也支持dou
自动类型转换
基本数据类型除了boolean都可以互相转换 在一起运算的时候小的转换成大的类型再运算
short byte char平级不可以自动互相转换 short byte char在运行时都会转换成int类型的数据载进行运算返回的也是int
强制类型转换 大转小
编译器通常默认小数为double float小数后面要加f
int float 不能互相转换 double long也是会损失精度
数值溢出时即不警告也不会出现异常 而是会把溢出值减去最大值返回
return 用于结束方法 指定返回值
break 用于强制跳出循环 直接结束所哟循环
continue 立即跳出当前循环 从下一个循环开始
goto：java保留字 java中没有goto语句
标签:后面有冒号的标识符 用于多重循环
写在循环语句前面 continue 标签跳到标签指定循环，执行下一个循环
break 标签 跳出标签所指定的循环 可用于直接结束多重循环
switch语句 选择执行
switch(表达式）{
case(数值1）：字段 ；breakl；
case(数值2）：字段；break；
...
default:字段：}
enum

this关键字：this表示当前类对象 用在方法中表示调用这个方法的类对象 用在本类中表示本类的对象 还可以用于在构造器中调用另一个构造器 this（）会根据参数类型选择哪个
构造器，但是必须写在代码的第一行

创建对象 首先检出类加载没有 加载了就进行初始化 初始化先是父类的静态成员 静态代码块 谁在前面先执行谁 然后是子类的静态成员静态代码块 然后是父类的 构造代码块
非静态成员 构造方法顺序执行 最后子类

数组
1. 数组是用来存储一组相同类型数据的数据结构。
2. 数组变量属于引用数据类型。
3. 数组是有固定长度的。
4. 数组中的元素可以是任何数据类型(基本类型和引用类型)。
5. 数组有一个对应的索引，可以通过索引访问数组中的每个元素。（0 –-- n-1）
6. 数组被创建好之后，它的大小（数组长度）是不能改变的，但是数组中的各个元素是可以被改变的。
访问权限：默认访问权限（包访问权限） public private本类可见 protected本类和子类中可见
jvm运行时内存划分 程序计数器 栈帧 本地方法栈 方法区 堆
Arrays工具类
获取数组长度：数组.length
将数组变成字符串：String Arrays.tostring(基本数据类型数组或object数组) 如果数组为空则返回空 使用String.valueOf()转换成字符串
对数组进行升序排序：[] Arrays.sort(数组)
对部分数组进行升序排序：Arrays.sort(数组，start，end)
按照指定的比较器对数组进行升序排序：Arrays.sort(数组，指定比较器comparator）
基于数组的内容计算哈希值：int Arrays.hashCode() 只有当两个数组相同时返回的哈希值才一样 数组为null 返回0
比较两个数组是否相等：boolean Arrays.equals(a[] ,b[])
使用二分查找法搜索指定的值，必须已经排序好：int Arrays.binarySearch([] ,start ,end,value) 如果包含在数组中则返回数组的引索，否则返回—插入点-1
根据指定的比较器用二分查找指定的值，排序的比较器需要与搜索的比较器相同：int Arrays.binarySearch([],start,end,comparator)
截取一个新长度的数组：[] Arrays.copyOf([],newlength) 如果新数组长度大于原数组则用零值填充
截取指定范围内的数组：[] Arrays.copyOfRange([] ，strat ,end)end可在数组范围之外
使用指定数值填充指定范围的数组： [] Arrays.fill([],start,end,value)
数组变列表： List asList(T...t)
集合变数组：toArray(T[]要转的数组类型)方法
对于数组
int[] a=new int[]{23,43,21,3,454,1,563,2121}
选择排序：
int n=a.length;
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
if(a[i]>a[j]){
int w=a[i];
a[i]=a[j];
a[j]=w;
}}}

冒泡排序
int n=a.length;
for(int i=0;i<n;i++){
for(int j=0;j+1<n-i;j++){
if(a[j]>a[j+1])
{
int w=a[j];
a[j]=a[j+1];
a[j+1]=w;

}}}
插入排序
int n=a.length;
for(int i=1;i<n;i++){
int j=i;
while(j>0&&a[j]<a[j-1])
{
int w=a[j];
a[j]=a[j-1];
a[j-1]=w;
j--;

}}
插入排序优于以上两种
二分查找法：
用于对有序的数组进行查找
public static int binarySearch(int[] arr,int value) {
int min=0;
int max=arr.length-1;
int index=0;
while(min<=max) {

int mid=(min+max)/2;
if(value==arr[mid]) {
return mid;
}
if(value>arr[mid]) {
min=mid+1;
index=mid+1;
}
if(value<arr[mid]) {
max=mid-1;
index=mid;
}

}

return -index-1;

}

匿名对象：当对象只调用一次时使用，new 构造方法可直接创造一个对象但是没有引用
主函数的特点:
1.格式是固定的
2.被jvm所识别
3.程序运行时，jvm会加载public class，然后从main函数开始执行

静态方法：被static所修饰的方法，如果一个方法不直接访问非静态成员，则可定义成静态。
java中本类中的同名全局变量与局部变量可用this区分 子父类的成员同名用super区分
子类会继承父类中所有德非private属性方法，一个父类有多个子类，一个子类只有一个父类。
覆盖：子类可以重写父类的方法称为覆盖，同时也可以覆盖同名属性,多态：一个动物多种形态。
覆盖时的注意事项：
1子类方法的权限必须要大于父类方法
2.静态方法只能覆盖静态方法或者被静态覆盖
this super
属性访问：访问本类中的属性，如果本类没有这些属性则从父类中查找。 属性访问：访问父类中的属性
方法：访问本类中的方法，如果本类没有则从父类中查找。 方法：直接访问父类中的方法
调用构造：调用本类构造，必须放在构造方法首行。 调用构造：调用父类构造，必须放在子类构造方法的首行。
特殊：表示当前对象。 特殊：无此概念

final关键字
1.修饰符，可用来修饰类、方法、变量
2、final修饰的方法不可以被覆盖
3.final修饰的类不能被继承
4、final修饰的变量为常量，必须在创造的时候赋值，且只能赋值一次

抽象类
1.抽象类抽象方法必须要用abstract修饰
2.抽象类中不一定有抽象方法，但是但是有抽象方法的类一定要被abstract修饰
3.抽象类没有实列 猫狗是类动物是抽象类，动物是没有单个实体的，是对猫狗这些生物的抽象
4.抽象类不能创建对象但是有构造方法，构造方法用于子类在访问抽象父类时初始化
5.抽象方法只有方法声明没有方法体
6.抽象类的子类要想实列化父类必须要覆盖所有的抽象方法。

如果一个类没有抽象方法也可以被abstract修饰，目的是不让其实例化。

借口interface
抽象类是从多个类中抽象出来的模版，如果抽象的更彻底就可以得到接口
接口的用处，用于扩展类的方法。
命名规则 修饰符 interface 接口名 extend 接口名
接口只能继承接口，不能继承类
接口定义的是一种规范，没有构造器不能初始化
接口里定义的是多个类的公共行为规范，应此接口类的所有常量、方法、内部类和内部枚举都是public访问权限
接口内的成员变量都是常量 即使不写也会默认被public final static 修饰
接口中方法有抽象方法 类方法（静态方法） 默认方法（接口中唯一有方法体的方法，用default修饰）接口中的普通方法不管写没写默认被public abstact修饰
抽象类能够定义非 static final 的属性(field)
，而接口不能。接口的属性都是static final的。
抽象类能够定义非public方法，而接口不能。接口的方法都是public的。
在Java中可以使用instanceof关键字判断一个对象到底是不是一个类的实例。
内部类：
成员内部类访问特点：
1.内部类可以直接访问外部类中的成员，包括私有成员
2.外部类要访问内部类的成员必须要创建对象
内部类分为 1.成员内部类 2.局部内部类（只能访问作用域内的常量） 3.静态内部类 4.匿名内部类
访问外部类中的内部类 Outer.Inner in = new Outer().new Inner()
内部类可以通过外部类名.this.引用的方法调用外部类成员
如果一个类要被声明为static的，只有一种情况，就是静态内部类
静态内部类的特点：
1.静态内部类跟静态方法一样，只能访问外部类静态的成员变量和方法，不能访问非静态的方法和属性，但是普通内部类可以访问任意外部类的成员变量和方法
2.静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法
3.静态内部类可以单独初始化:
4.静态内部类可以访问外部类的静态成员
Inner i = new Outer.Inner();
静态内部类的使用场景是，当外部类需要使用内部类，而内部类不需要使用外部类的资源时，可以考虑静态内部类，相当于一个外部类。
匿名内部类:用于只使用一次的内部类
要使用匿名内部类必须要继承一个类或者实现一个接口

泛型类：参数类型化，也就是说参数的类型被指定为一个参数用字母T代替
好处将运行期间出现的异常转到了编译期间
1.泛型类
class 类名〈T，W...〉{
private T t;
private W w;
...setter和getter
}
泛型不能用在静态属性上
因为泛型的类型在创建对象的时候才能确定，所以类加载要执行的静态成员静态代码块中都不可以使用泛型

泛型不能使用在基本数据类型上 不能使用int 而是应该使用integer
实现原理
类型消除，在编译时使用泛型编译，编译成功后会使用原始的类型替代泛型进行运行，jvm不能识别泛型只能识别具体类型
不能对泛型类进行instanceof操作，编译会报错
2.泛型接口
public interface Comparator<T t> {
public copare(T t){
}
}
接口中泛型不能使用在全局常量上（类的属性上）：应为接口中全局变量都是public static final

3.泛型方法
当在泛型类中时同2
当没有定义在泛型类中时
public <T> void method（T t){}一般都是在返回值之前加<字母>

泛型的继承
父类方法使用了泛型时，子类继承父类，子类也必须继承父类的泛型，并且子类泛型>=父类泛型

注意要点：
泛型确定是一个什么类型的参数时，那么传入得参数就必须是什么类型，不可以传子类
编译器不允许创建泛型变量的数组

泛型的限定
当传入的泛型类型不能够确定时可以以使用通配符？通陪符的作用是在参数类型不确定的时候使用
？可视做所有类型的父类 ，实参而不是形参。当操作类型时，不需要使用类型的具体方法，只需要使用object方法，就可以使用？
泛型的限定：
？extends E:接受E和E的子类
？super E:接受E和E的父类

基本数据类型的包装类：
抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类
Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法 类型Value()
integer
常量 MAX_VALUE MIN_VALUE SIZE TYPE
构造方法：integer（int) integer(String str) 使用与 parseInt 方法（对基数为 10 的值）相同的方式将该字符串转换成 int 值
常用方法：
进制的转换
1.返回二进制的表示形式：static String toBinaryString(int)
2.返回八进制的表示形式：static String toOctalString(int)
3.返回十六进制的表示形式：static String toHexString(int)
4.其他进制数转10进制数： static int ParseInt(String str,基数)

整形化字符串toString（）
字符串化整型static int ParseInt(String str)除了第一位可以是减号外字符串必须是数字形式的字符串
static int valueOf()与parseInt一样

comparable<T> 所有可以比较的类都实现了comparable接口，覆盖了compareTo()方法

集合
Collection<E>
1.用于存储对象的容器
2.集合的长度是可以改变的
3.集合众不可以存储基本数据类型

集合容器因为内部数据结构的不同，有多种具体的容器

集合的常用方法：
1.添加
boolean add（? extends E e)
Boolean addAll(collection<? extends E>)

2.删除remove clear

3.判断cotains containsAll isEmpty

4.获取 size Iterator iterator 返回迭代器

5.变数组 <T> T[] toArray(T[] a)需要指定新数组的长度 长了补null 短了砍

6.保留两个集合相交的部分retainAll

Iterator 的使用方法
、Iteratot it=coll.iterator()

方法
1.hasNext()还有下一个元素则为真
2.next（）返回下一个元素
3.remove（）移除迭代器返回的最后一个元素，只能使用一次

Iterator 是所有集合的接口，作用是提供取出集合元素的方法

List〈T>接口 列表集合 允许元素重复 元素都有引索
方法
1.添加 add在末尾添加元素 addAll add(index,e) addAll(index,list)在指定脚标处添加元素

2.删 clear（） rmove(index) remove(e) removeAll(list) retainAll

3.查 isEmpty size contains containsAll get(index) indexOf(e) lastIndexOf(e)
返回列表的一部分subList(start,end)

4.改 set（index，e)

特殊的迭代器listIterator 允许程序员按任一方向遍历列表、迭代期间修改列表
hasNext() Next() add将指定的元素插入列表（可选操作）。该元素直接插入到 next 返回的下一个元素的前面,将指定的元素插入列表（可选操作）
该元素直接插入到 previous 返回的下一个元素的后面 nextIndex hasPrivious privious previousIndex set remove

List下的类：vectory:内部是数组数据结构，同步的
arrayList:数组数据结构 ，不同步，查找快
linkledList:内部是链式的数据结构，增删快，不同步
arrayList 方法基本与list方法相同
linkedList
新增常用方法：
1.增 addFirst addLast
2.删 romoveFirst romoveLast 移除并返回 removeFirstOccurence(e) removeLastOccurence(e)
4.查.getFirst getLast
jdk1.6以后 get=peak remove=poll add=offer

set 元素不重复 没有引索
hashSet
元素的排列根据元素的hashcode来确定 要改变排法就要改变 覆盖hashCode方法

linkedHashSet具有可预知的迭代顺序的set接口的哈希表和链表实现，iterator是按什么顺序存的就怎么取出来

treeSet：数据结构是二叉树 可以对集合中的元素进行排序

TreeSet对元素进行排序的方式有了两种
1.元素自身实现了comparable接口
2.指定一个comparator比较器，按照比较器的方法排序
写比较器的方法 继承comparator 并且覆盖compare方法