文章目录
-
- java概述
- Java基础
- 面向对象
- 数组
- String类 StringBuffer/StringBuilder
- 八种基本数据类型对应的包装类
- 常用类
- 异常处理机制
- 线程
- 泛型
- 集合
- IO流
- 反射
- 注解
- 目前知道的设计模式
java概述
1.语言的发展历史和Java语言概述
1)语言的发展史
机器语言
低级语言 汇编语言
高级语言
C语言：面向过程的
C++语言：一半面向过程，一半面向对象
Java语言：完全面向对象（java语言底层实际上是C++实现的。）
Python语言：面向对象
2)Java语言发展史
98年的时候：Java升级到JDK1.2，Java被分为三大块：
J2SE：标准版（基础，要学java，必须先学习SE。基础语法+基础库）
J2EE：企业版（专门为企业开发软件，为企业提供解决方案。
例如：OA办公系统，保险行业的系 统，金融行业的系统，医院系统....）
J2ME：微型版（专门为微型设备做嵌入式开发的。）
java诞生十周年改了名字：
JavaSE
JavaEE
JavaME
2.Java语言的特性
1)简单性
在Java语言当中真正操作内存的是：JVM（Java虚拟机）
2)java是堪称完全面向对象的。
面向对象更容易让人理解，人类通常是以对象的方式认知世界的。
采用面向对象的方式可以让复杂问题简单化。
3)健壮性
主要是因为Java中有一种机制：
自动垃圾回收机制（GC机制）。
4)java完全/完美支持多线程并发。
5)可移植性/跨平台
java语言只要编写一次，可以做到到处运行。
例如：java程序编写完之后，可以运行在windows操作系统上，
不需要做任何改动可以直接运行在Linux操作系统上，同样也
可以运行到MaC OS上面。
一次编写，到处运行。（平台改变了，程序不需要改。）
3.JDK JVM JRE
1)
JDK:Java开发工具箱
JRE:java运行环境
JVM:java虚拟机
2)
JDK包括JRE，JRE包括JVM。
3)
JVM是不能独立安装的。
JRE和JDK都是可以独立安装的。
有单独的JDK安装包。
也有单独的JRE安装包。
没有单独的JVM安装包。
4)
安装JDK的时候：JRE就自动安装了，同时JRE内部的JVM也就自动安装了。
安装JRE的时候：JVM也就自动安装了。
4.配置环境变量
1)什么是path?
系统默认查找应用程序的路径,配置它就是为了更好的使用JDK工具包内的工具,
主要就是javac.exe,java.exe,javadoc.exe.....
2)什么是slasspath?
classpath: java在运行时要找的class文件所在的路径（注意与编译无关），与path相反，
先找设置的目录,在查找当前目录。（”.”表示当前目录，设置classpath的时在最后一个目
录后不要写分号,因为不加分号就不会查找当前目录）
4.对java程序的加载和执行的理解
1)java程序从编写到最终运行经历了哪些过程？？？？
java程序非常重要的两个阶段：
编译阶段
运行阶段
2)注意：java程序员直接编写的java代码（普通文本）是无法执行被JVM
识别的。java程序员编写的java代码这种普通文本必须经过一个编译，
将这个“普通文本代码”变成“字节码”，JVM能够识别“字节码”。
java代码这种普通文本变成字节码的过程，被称为：编译。
java代码这种普通文本被称为：java源代码。（你编写的代码是源代码）
源代码不能直接执行，需要先进行编译，生成源代码对应的“字节码”
JVM可以识别的是字节码。
编译阶段和运行阶段可以在不同的操作系统上完成
在windows上编译之后生成了“字节码”,可以放到linux上运行,因为Java是跨平台的。
可以做到一次编写到处运行。
3)放源代码的文件扩展名必须是：xxx.java
并且需要注意的是：编译生成的字节码文件扩展名是：xxx.class
4)另外需要注意的是：
1个java源文件是可以编译生成多个class文件的。
最终运行的是class文件。
5)java程序从开发到最终运行步骤
新建java文件
打开java文件
写java源代码
保存
javac命令编译
java命令运行
编写、编译、运行
5.第一个程序HelloWorld
练习一下coding能力,不要满嘴各种框架,结果HelloWorld报错!!!!呵呵呵
Java基础
1.标识符和关键字
1)标识符
*在java中可以自己命名的都是标识符 类名,变量名,方法名
*标识符的命名规则
只能以数字,字母,"_",$ 符号组成
不能以数字开头
关键字不能作为标识符
理论上没有长度限制
*标识符命名规范
见名知意
遵循驼峰命名规范
类名 每个单词首字母大写
变量名,方法名(函数名)第一个全部小写,其他单词首字母大写
常量名 每个字母全部大写,单词与单词之间以下划线隔开
2)关键字
*在SUN公司开发Java语言的时候，提前定义好了一些具有特殊含义的单词，
这些单词全部小写，具有特殊含义，不能用作标识符。
*java语言中的所有关键字都是全部小写。
注意：java语言中是严格区分大小写的。public和Public不一样。
Class和class不一样。static和Static也不一样。
2.变量和数据类型
1)变量
*java变量是程序中最基本的存储单元,其要素包括 变量名,变量类型和作用域
*变量申明 数据类型 变量名 = 值
从本质上来说,变量就是内存中的一小块区域,使用变量名来访问这块区域,因此每
一个变量使用前必须要先申明,然后必须进行赋值,才能使用
*变量的分类
按被申明的位置划分:
局部变量
成员变量
按所属的数据类型划分
基本数据类型
引用数据类型
2)数据类型
*数据类型是用来申明变量的,程序在运行过程中根据不同的数据类型分配不同的大小空间
*数据类型在java中包括两种
基本数据类型
第一种 基本数据类型又可以划分为四大类8小种
第一类:整数型
byte short int long
第二类:浮点型
float double (带小数的)
第三类:布尔型
boolean 只有两个值 true 和false
第四类:字符型
char java中规定字符型字面量必须用' '括起来
8小种
byte short int long
float double boolean char
引用数据类型
除基本数据类型外的其他数据类型为引用数据类型
*字符型char
在java中字符采用Unicode编码,每个字符占用两个字节
*整数类型 byte short int long
java整数型字面量默认用int型 ,声明long字面量可以后加"l"或"L"
*浮点型 float double
java中浮点型字面量默认用double,声明float字面量可以后加"f"或"F"
*基本数据类型转换
八种基本数据类型中,除boolean类型不能转换,其余七种都可以进行转换;
如果整数型字面量没有超过byte short char 的取值范围,可以直接将其赋值给
byte short char类型的变量;
小容量向大容量的转换称为自动类型转换,容量从小到大排序为:
byte < short(char) < int < long < float < double,其中short 和char都占
两个字节,但是char可以表示更大的正整数;
大容量向小容量转换称为强制类型转换,编写时,必须添加强制类型转换符,但是运行时
可能会损失精度,谨慎使用;
byte short char 类型做混合运算时,各自转换为int类型在做运算;
多种数据类型做混合运算时,各自先转换为容量大大数据类型再做运算;
*基本数据类型占用字节数和默认值
byte 1 0
short 2 0
int 4 0
long 8 0L
float 4 0.0f
double 8 0.0d
boolean 1 false
char 2 \u0000
3.运算符
算术运算符
+ - * / % ++ --
关系运算符
> < >= <= == !=
逻辑运算符
& | && || !
赋值运算符
= += -= /= %=
三目运算符
布尔表达式 ? 表达式1 : 表达式2;
字符串连接符
+
4.键盘输入
java.util.Scanner s = new java.util.Scanner(System.in);
import java.util.Scanner;
Scanner s = new Scanner(System.in);
接收整数
int a = s.nextInt();
接收字符串
String st = s.next;
5.控制语句
1)控制语句出现让代码更具有逻辑性和条理性,可以使用控制语句来实现一个业务
2)控制语句的分类
选择语句
选择语句也可以叫分支语句
if语句
switch语句
循环语句
for
while
do..while
foreach
转向语句
break
continue
return
6.方法
1)方法是一段可以完成某一个特定功能的并且可以被重复利用的代码片段
方法的出现,让代码具有了很强的复用性
2)方法的定义
[修饰符列表] 返回值类型 方法名 (形式参数列表){}{
方法体;
}
调用:
方法名(实参) 实参与形参一一对应
3)方法重载
*当方法的功能相似的,建议将方法名第一位一致的
*构成方法重载的条件
条件1 在同一个类中
条件2 方法名相同
条件3 形式参数列表不同(类型 个数 顺序)
注意:方法重载与返回值类型无关,和修饰符列表无关
4)方法递归
方法自身调用自身
面向对象
1.面向对象和面向过程
1)面向过程
注重的是实现这个功能的步骤
第一步干什么
第二不干什么
........
面向过程也注重实现这个功能的因果关系
因为A所以B
因为B所以C
因为C所以D
.........
面向过程没有对象的概念,只是实现这个功能的步骤和因果关系
缺点:高耦合度,扩展力差
优点:快速开发,无需前期对象的抽取,上来就开始写代码
2)面向对象
*面向对象来源于生活,面向对象就是将现实世界分割成一个不同的单元,然后每个单元都
实现成对象,然后给一个环境驱动,让各个对象协作起来形成形成一个系统;
面向对象是相对于面向过程的;
面向对象是一种思想;
面向对象开发就是不断的创建对象,使用对象,指挥对象做事情
设计的过程: 其实就是管理对象与对象之间的关系
2.面向对象的三大特性
封装
继承
多态
3.类和对象的概念
1)类
*类是具体事务的抽象,概念上的定义
*类的定义
生活中描述事物无非就是描述事物的属性和行为
Java中用类class描述事物也是如此
属性:对应类中的成员变量]
方法:对应类中的实例方法
[修饰符列表] class 类名{
属性+方法
}
定义了一个类就相当于自定义了一种数据类型
2)对象
*对象即是该类事物实实在在存在的个体
创建对象方式
类型 引用 = new 构造方法();
4.构造方法
1)构造方法是类中特殊的方法,通过调用构造方法来完成对象的创建,以及对象属性的初始化操作
2)语法
[修饰符列表] 构造方法名 (形式参数列表){
构造方法体;
}
*构造方法名和类名一致
*构造方法用来创建对象,完成属性的初始化操作
*构造方法返回值类型不需要写,写上就报错,包括void也不能写
*构造方法的返回值类型实际就是当前类的类型
*一个类中可以定义多个构造方法,这些方法构成方法重载
3)new 构造方法名(实际参数列表) 调用构造方法方式
4)当一个类中没有显示定义任何构造方法的时候,系统默认提供无参数构造方法,
当显示定义有参数构造方法之后,系统将不再提供无参数构造方法;
无参数构造方法又叫做缺省构造器,或者默认构造方法;
一般在开发中要把缺省构造器手动写上;
5.封装详解
1)封装:是指隐藏对象的属性和实现细节,仅对外提供公共的访问的访问方式
2)好处:
将变化隔离
便于使用
提高重用性
提高安全性
3)封装代码实现方式
*属性私有化(使用private关键字进行修饰)
*一个属性对外提供两个方法,get和set方法.外部只能通过set方法修改,通过get方法读取数据,
可以在set方法中设立关卡来保证数据的安全性和合法性
注意:
set和get方法都是实例方法,不能带static
不带static的方法称为实例方法,实例方法的调用必须先new对象;
set和get方法写的时候有严格的规范要求: (请按规范写,但是idea生成是真的香香)
set方法:
public void set+属性名首字母大写(一个参数){
this.xxx = 一个参数;
}
get方法:
public 返回值类型 get+属性名首字母大写(无参){
return xxx;
}
6.static关键字
1)static是一个修饰符,用于修饰成员
2)static修饰的成员被所有对象所共享
3)static优先与对象存在,因为static的成员随着类的加载就已经存在了
4)static修饰的成员多了一种调用方式,就可以直接被类名所调用. 类名.静态成员
5)static修饰的数据共享的数据,对象中的存储的是特有的数据
6)成员变量和静态变量的区别?
*两个变量的生命周期不同.
成员变量随着对象的创建而存在,随着对象的回收而被释放
静态变量随着类的加载而存在,随着类的消失而消失
*调用方式不同
成员变量只能被对象调用
静态变量可以被对象调用,还可以被类名嗲用
*别名不同
成员变量也称为实例变量
静态变量称为类变量
*数据存储位置不同
成员变量数据存储堆内存的对象中,所以也叫对象的特有数据
静态变量数据存储在方法区的静态区,所以也叫对象的共享数据
7)static代码块 静态代码块
静态代码块先与主方法执行,在类中静态代码先与构造代码块执行,
代码块又先于构造方法执行
7.this关键字
*this是一个关键字,是一个引用,保存内存地址指向自身
*this可以使用在实例方法中,也可以使用在构造方法中
*this出现在实例方法中其实代表的是当前对象
*this不能出现在静态方法中
*this. 大部分可以省略,但是用来区分局部变量和实例变量的时候不能省略
*this() 这种语法只能出现在构造方法第一行,表示当前构造方法调用本类的其他构造方法,目的是代码复用
8.extends继承
1)继承的作用
基本作用:子类继承父类,代码可以得到复用
主要作用:因为有了继承关系,才有了后期的方法覆盖和多态机制
2)继承的的相关特性
*B类继承A类,则称A类为超类 父类 基类,B类称为子类 派生类 扩展类
class A{}
class B extends A{}
*java中继承只支持单继承,不支持多继承
*虽然java中不支持多继承,但是有的时候会产生间接继承效果
*java中规定,之类继承父类,除构造方法不能继承外,剩下的都可以继承,但是私有的属性无法在在子类
中直接访问.(父类private修饰的不能在子类中直接访问,可以通过间接的方式访问)
*java中的类没有显示继承任何类,则默认继承Object类,Objectshi所有类的老祖宗类,也就是说一个对象
与生俱来就具有Object类型中的所有特征
*继承也存在一些缺点.......
3)在实际开发中凡是采用"is a"能描述,都可以继承,例如
Cat is a Animal 猫是一个动物
Dog is a Animal 狗是一个动物
Apple is a Fruit 苹果是一个水果
............
9.方法覆盖Override
1)父类中的方法无法满足子类的业务需求,子类有必要对继承过来的方法进行覆盖
2)满足方法覆盖的情况
*有继承关系的两个类
*具有相同的方法名 返回值类型 形式参数列表
*访问权限不能更低
*抛出的异常不能更多
10.多态
1)向上转型和向下转型的概念
向上转型 :子----->父 (upcasting) 又被称为自动类型转换
Animal a = new Cat();
向下转型: 父----->子 (downcasting) 又被称为强制类型转换
在需要调用或者执行子类对象中特用的方法,必须进行向下转型,才能调用;
向下转型容易出现ClassCastException(类型转换异常);
使用instanceof运算符,可以在程序运行阶段动态的判断某个引用指向的对象是否为某一种类型;
养成好的习惯,向下转型之前一定要使用instanceof运算符进行判断,代码更具健壮性
不管向下转型还是向上转型,首先它们必须具有继承关系
2)多态概念
多种形态,多种状态,编译和运行有两种不同的状态.
编译期叫做静态绑定
运行期叫做动态绑定
多态的典型代码:父类的引用指向子类型的对象
3)多态作用:降低程序耦合度,提高程序扩展力
11.super关键字
*super能出现在实例方法和构造方法中
*super语法: "super." "super()"
*super不能使用在静态方法中
*super. 大部分情况可以省略
分类和子类中有同名属性,或者是有同样的方法,在子类中访问父类的 super. 不能省略
*super()只能出现在构造方法的第一行
12.final关键字
*final关键字表示最终的不可变得
*final修饰的类无法被继承
*final修饰的方法无法被覆盖
*final修饰的变量只能赋一次值
*final修饰的引用一旦指向某一个对象,则不能再指向其他对象,但该引用指向的对象的内部数据是可以修改的
*final修饰的实例变量必须手动初始化,不能采取系统默认值
*final修饰的变量一般和static联合使用,称为常量
public static final double PI = 3.1415926
13.抽象类
1)抽象定义:
抽象就是从多个事物中将共性,本质的内容抽取出来
2)抽象类定义:
在class前添加abstract关键字就好了
3)抽象类是无法实例化的,无法创建对象,所以抽象类是用来被子类继承的
4)final和abstract不能联合使用,这两个关键字是对立的
5)抽象类的子类可以是抽象类,也可以是非抽象类
6)抽象类虽然无法实例化,但是抽象类有构造方法这个构造方法是提供给子类使用的
7)抽象类中不一定有抽象方法,但是抽象方法必须出现在抽象类中
8)抽象方法定义:
public abstract void doSome();
9)一个非抽象的类,继承抽象类,必须将抽象类中的抽象方法进行覆盖/重写/实现
14.接口
1)接口是一种"引用数据类型"
2)接口是完全抽象的
3)接口定义:
[修饰符列表] interface 接口名{ }
4)接口支持多继承
5)接口中只有常量+抽象方法
6)接口中所有的元素都是public 修饰的
7)接口中抽象方法public abstract可以省略
8)接口中常量的public static final可以省略
9)接口中方法没有方法体
10)接口的作用
解耦合
15.package和import
1)packge出现在java源文件的第一行
javac -d .xxx.java 带包编译
java 完整类名 运行java程序
2)import
import+完整类名;
16.访问控制权限
1)4种访问控制权限
private 私有的 只在本类中能访问
public 公开的 在任何位置都可以访问
protected 受保护的 只能在本类 同包 子类中访问
默认 只能在本类中,以及同包下访问
2)能修饰的:
属性(4个都可以)
方法(4个都可以)
类(public和默认能用,其他不行)
接口(public 和默认能用,其他不行)
(可能不准确.......)
......
17.JDK类库的根类：Object
1)任何一个类默认继承Object或者间接继承Object
2)常用方法
protected Object clone() //负责对象的克隆 不得不提一下Cloneable接口,后续的集合也实现了该接口
int hashCode() //获取对象哈希值的方法 一般类中我们要进行重写
boolean equals(Object obj) //判断两个对象是否相等
//源码中比较的是两个对象的内存地址,所以我们要进行重写,你是上帝,想怎么重写就怎么重写
//String类equals()已经重写了
String toString() //将对象转换成字符串形式
//以后所有类的toString()方法都要重写,重写的规则是越简单简明越好
//System.out.println(引用); 这里会自动调用"引用"的toString()方法
//String类的toString()方法已经重写了
protected void finalize() //垃圾回收器负责调用的方法
.......
其他请自行查看API或者看源代码 多看源代码,感受下下鬼斧神工
18.内部类
*将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类 嵌套类)
*访问特点:
内部可以直接访问外部类中的成员,包括私有成员
而外部类要访问内部类中的成员必须建立内部类的对象
*内部类编译生成的字节码文件名:Outer$Inner.class
*匿名内部类
就是内部类的简化写法
前提:
内部类可以继承或者实现一个外部类或者接口
格式为:
new外部类名或者接口名(){覆盖类或接口中的代码}
数组
1.数组概述
数组可以看成是多个相同类型数据的组合,对这些数据的统一管理
数组变量属于引用类型,数组可以看成是对象,数组中的每个元素相当于该对象的成员变量
数组中的元素可以是任何数据类型,包括基本数据类型和引用型
2.数组的优缺点,并且原因
*空间存储上,内存地址是连续的
*每个元素占用的空间大小相同
*知道首元素的内存地址
*通过下标可以计算出偏移量
通过一个数学表达式,就可以快速的计算出某个下标位置元素的内存地址,直接通过内存地址定位,效率非常高
优点: 检索效率高
缺点: 随机增删效率比较低,数组无法存储大数据量
注意: 数组最后一个元素的增删效率不受影响
(增删可以自己写个算法,缩小这个缺陷)
3.一维数组的静态初始化和动态初始化
*静态初始化
int[] arr = {1,2,3,4};
Object [] objs = {new Object(),new Object(),new Object()};
*动态初始化:
int[] arr = new int[4]; //长度为4,每个元素默认值0
Object[] objs = new Object[4] //长度为4,每个元素默认值为null
4.一维数组的遍历
for(int i = 0 ;i < arr.length ; i++){
System.out.println(arr[i]);
}
5.二位数组的静态初始化和动态初始化及遍历
同上类似
注意:下标越界会出现 ArrayIndexOutBoundsException 数组下标越界异常
6.数组的拷贝扩容
System.arraycopy()方法
*数组有一个特点:长度一旦确定,不可变.
所以数组的长度不够的时候,需要扩容,扩容的底层机制是:
新建一个大数组,将小数组中的数据拷贝到大数组,然后小数组对象被垃圾回收
//当然扩容的效率比较低,尽量避免 后面集合ArrayList底层是数组
7.常见算法
*排序算法
冒泡排序算法
选择排序算法
.......
请百度或者小破站....
*查找算法
二分法查找
能手写伪代码
8.java.util.Arrays工具类
*所有方法都是静态的,直接用类名调用
* Arrays.sort(arr) //排序
Arrays.binarySearch(arr,要搜索的值) //二分法查找
Arrays.toString(arr) //返回指定数组的字符串形式
其他请自行查看API.........
String类 StringBuffer/StringBuilder
1.java.lang.String类
1)*String表示字符串类型,属于引用数据类型
*在java中使用双引号括起来的都是String对象.例如:"abc" "bcd"
*java中规定双括号括起来的字符串,是不可变的,源码中采用final修饰;
也就是说"abc"从出生到销毁都不可变,不能变成"abcd" ,浪费空间
*在java中字符串都直接存储在"方法区"的"字符串常量池"当中,因为在实际开发中字符串使用频繁,为了执行效率
SUN公司这样设计
2)常用的构造方法
*new String("");
*String s = " ";
*String(byte[] bytes) //将byte数组构造成一个新的String
*String(byte[] bytes ,int offset, int length) //String(字节数组,数组元素的下标起始位置,长度)
*String(char[] chars) //将char数组全部装换为字符串
*String(char[] chars ,char offset ,int count) //将char数组一部分转换为字符串
3)常用方法
*char charAt(int index) //取出指定索引的字符
*int compareTo(String anotherString) //字符串之间比较大小不能直接使用> < ,需要使用compareTo方法
//结果有三种情况
//等于0 前后一致
//小于0 前小后大
//大于0 前大后小
*boolean contains(CharSequence s) //判断前面的字符串是否包含后面的子字符
*boolean endsWith(String suffix) //判断当前字符串是否以某个子字符串结尾
*boolean startsWith(String prefix) //判断当前字符串是否以某个子字符串开头
*boolean equals(Object anObject) //比较两个字符串必须使用equals方法;
//equals只能看出相等不相等
//compareTo可以看出是否相等,并且同时还可以看出谁大谁小
*boolean equalsIgnoreCase(String anotherString) //判断两个字符串是否相等,并且同时忽略大小写
*byte[] getBytes() //将字符串对象转换成字节数组
*int indexOf(String str) //返回某个字符串在当前字符串中第一次出现处的索引
*int lastIndexOf(String str) //返回某个子字符串在当前字符串最后一次出现的下标
*boolean isEmpty() //判断某个字符串是否为"空串" 底层调用了length()方法
*int length() //返回字符串的长度 返回数组的长度是length属性
*String replace(CharSequence taget , CharSequence replacement) //替换
//String的父接口就是CharSequace
*String[] split(String regex) //根据匹配的正则拆分字符串
*String substring(int beginIndex) //截取字符串 参数是起始下标
*String substring(int beginIndex ,int endIndex) //截取字符串
//beginIndex起始位置(包括)
//endImdex 结束位置(不包括)
*char[] toCharArray() //将字符串转换为char数组
*String toLowerCase() //转换为小写
*String toUpperCase() //转换为大写
*String trim() //去除字符串前后空白
*static String valueOf() //静态方法 参数是一个对象时,会自动调用该对象的toString()方法
..........
2.java.lang.StringBuffer类
1)java中字符串是不可变的,每一次拼接都会产生新的字符串,会占用大量的方法区内存,造成内存浪费
建议使用StringBuffer类调用append()方法来完成字符串拼接
2)*StringBuffer底层实际是一个byte[]数组(字符串缓冲区对象)
*StringBuffer初始化容量是16
*拼接字符串统一调用 append() 方法
*append方法底层在追加的时候,如果byte数组满了,会自动扩容 所以在创建StringBuffer的时候尽
可能给定一个 合适的初始化容量
*线程安全
3.java.lang.StringBuilder类
同上类似
StringBuffer和StringBuilder区别
StringBuffer中的方法都有:synchronized关键字修饰 表示线程安全
StringBuilder中的方法都没有synchronized关键字修饰 表示线程不安全
八种基本数据类型对应的包装类
1.在java中万物皆对象.普通的8种基本数据类型不够用,SUN公司又提供了对应的8种包装类
2.8种基本数据对应的包装类型名
基本数据类型 包装类型
byte java.lang.Byte(父类Number)
short java.lang.Short(父类Number)
int java.lang.Intrger(父类Number)
long java.lang.Long(父类Number)
float java.lang.Float(父类Number)
double java.lang.Double(父类Number)
boolean java.lang.Boolean(父类Object)
char java.lang.Charcter(父类Object)
3.Number是一个抽象类,无法实例化对象
该类中的方法
*byte byteValue() //以byte形式返回指定的数值
*abstract double doubleValue() //以double形式返回指定的数值
*abstract float floatVauble() //以float形式返回指定的数值
*abstract int intVauble() //以int形式返回指定的数值
*abstract long longValue() //以long形式返回指定的数值
*short shortValue() //以short形式返回指定的数值
这些方法都是负责拆箱的
4.关于包装类的构造方法,每种都类似
Integer(int) //将数字转换为Interger包装类型 (int---->Integer)
Integer(String) //将String类型的数字转换为Iterger包装类型 (String ------>Integer)
........
5.基本数据类型 转换为 引用数据类型 装箱
引用数据类型 转换为 基本数据类型 拆箱
Java5之后,新特性 自动拆箱 自动装箱 Number中的方法就无用了
6.访问包装类中的常量,来获取最大值和最小值
Integer.MAX_VALUE
Integer.MIN_VALUE
...........
7.java中为了提高程序的执行效率,将[-128到127]之间的所有包装对象提前创建好了,放到了"整数常量池"当中
用到这个区间的数据不需要在new,直接在整数常量池当中取
8.NumberFormatException 数字格式化异常
9.static int parseInt(String s) //静态方法 传参,返回int
常用类
1.日期类
2.数字类
3.随机数
4.枚举
异常处理机制
线程
泛型
集合
IO流
反射
注解
目前知道的设计模式
