java从入门到放弃（一）
java从开始到放弃？
jdk:
软件开发工具包（包含jre和软件开发工具）（开发不同，jdk的大小不同，jdk的包也不同:javaee:企业版，javase:个人版，javame:袖珍版）
jre:
jvm和核心类库(编写简单java程序)（jar容器）
jvm:
JAVA跨平台的根本，（java虚拟机）
所以总结：只要安装jdk即可。
java基本语法
常量：
固定不变的量 整数，小数，布尔，字符，字符串
变量：
在内存中开辟一块空间，可以存储数据，但是一个变量只能存储一个值，这个值是可以改变的。
注释：
单行注释：//
多行注释：/**/
文档注释：/** */在方法中显示
关键字：
被java赋予了特殊含义的单词，只能用，不能改，也不能重名
标识符：
程序中需要我们自己命名的
由26个英语字母，数字，_,$组成
不能和关键字同名
不能以数字开头
区分大小写
数据类型：
规范变量的内存大小，空间（取值）
基本数据类型（数值型，整数型，浮点型，字符型，布尔型）和引用数据类型（数组，类，接口）
有符号数最高为符号位。
float 4个字节（科学计算法，牺牲精度，最大值比long大的多）
double 8个字节（科学计算法，牺牲精度，最大值比long大的多）
long 8个字节 int 4个字节 short 2个字节 byte 1 个字节
ASCII值（国标码）（中文字符码GBK一个汉字对应俩个字节 GB-2312）一个汉字对应三个字节（UTF-8）uncode （内部编码，俩个字节）lso8859-1(欧洲)（不支持中文）
大写A 65（32）
小写a 97
0 48
大整数类
确定数据类型的优先级，从低到高
char,byte-short-int-long-float-double
进制转换：
1B = 8b 1kB=1024B
1MB=1024kB 1GB=1024MB
1TB=1024GB 1PB=1024TB
System.out.println(14 + 'A' + 12);//字符转换成整数运算
运算符
第一：根据类型分类
算数运算符：+ - * / % ++ --，赋值运算符 = += -= *= /= %= ^=，逻辑运算符 & && (短路与：当多个&&出现时，一旦发现一个flase，停止运算 返回false。) | || (短路或：当多个||出现时，一旦发现一个true，停止运算 返回 true。) !，关系运算符 == < <= > >= != ，位运算符& | ^ ~（不存在短路与，短路或），移位运算符：>> << >>>
第二：根据操作元素个数分类
（异或：相同为0，不同为1）
一元运算符
二元运算符
三元运算符 ？ (true)：(flase)
多个式子运算时：
1.排除法：先找优先级最低的，考虑结合性
2.结合计算：
流程控制语句
实现现实中的逻辑(顺序，循环，分支（并列）三种结构)
分支
switch case final（多的话，用switch，少的用 if )
if else
循环：
for （起始 结束 自增）起始条件不成立，不影响结束条件的判断（循环起别名（标识））
for循环的执行顺序（注int i=1;可以写函数调用）
while 起始 结束 自增量
do while
foreach
函数（方法）
拥有一段特殊功能的代码。函数的作用：提高程序的安全性，复用性，健壮性，可读性，节省内存。
函数的参数，返回值，类型
public static int mytest() {
return (float)0;
}（错误）
全局变量：相对的概念。比局部变量更大的范围
成员变量：在堆区，创建有默认值。
局部变量：在栈区，没有默认值。
函数：在栈区。
对象：在堆区。
在java中内存分为
堆：实体，整型默认为0，布尔型默认是false。（内存中的一块区域，使用的底层队列结构）
栈：函数，局部变量，先进后出，使用完立刻释放（内存中的一块区域，使用的底层栈结构）
方法区，本地方法区，寄存器
释放机制：栈使用完立刻释放，堆里面的东西（通过垃圾回收机制释放）
递归：时间和空间的负责度（尽量避免递归）
重载：在同一类中，方法名相同，参数的个数，位置，类型不同，（与返回值无关）。作用：方便函数的编写，程序的执行。（构造方法）
数组
数组：存储多个数字；定义：可以同时存储多个相同类型的数据，他是引用数据类型，数组是被放在堆区的，有默认值，
构成:new + 数据类型 + [元素的个数]
new :在堆内开辟空间,将数组的地址返回
int代表元素的数据类型
[3];代表数据的个数
我们可以通过一个变量保存数组的地址,这个变量的类型是int型的数组类型.
注意:int+[]是一个整体,代表一种数据类型,不能拆开.[]中也不能写数.
int[] arr = new int[3];
解释:先拿arr(引用类型)中保存的地址找到数组,然后在根据下标找到具体的元素,完成赋值或者取值
如果下标超出了数的范围,会报下标越界异常
java.lang.ArrayIndexOutOfBoundsException
引用数据类型和基本数据类型：一个是值，一个是地址（16进制）new在堆区里动态开辟空间。存储地址的类型（引用数据类型）
第一个元素的地址充当整个数组的地址（数组的内存是连续的，所以数组有下标。）
初始化赋值创建
int[] arr1=new int[]{4,5,7};
int[] arr2= {5,7,8,9};//自动（new，分配空间）
数组作为参数的时候不能直接使用大括号的方式。
地址传递（参数数组）
在进行值传递的时候，函数里面无法影响的函数外
在进行址传递的时候，函数里面可以影响的函数外
二维数组
一维数组：首地址
二维数组：多个一维数组的地址。
[外链图片转存失败(img-iwyAvUD9-1568960839567)(C:\Users\zhaoboshi\AppData\Roaming\Typora\typora-user-images\1563937957499.png)]
int[][] arr3 ={{4,5},{3,4,5,6}};
int[][] arr2=new int[2][4];
arr2[0] = new int[3];
arr2[1] = new int[] {3,4,5};
arr2[2] = new int[3];
排序
平均时间复杂度(牺牲空间，调高时间复杂度，提升用户体验)
插入排序O(n^2)
冒泡排序
O(n^2)(循环首选最大值，俩个数比较)
选择排序
快速排序O(n log n)
堆排序O(n log n)
归并排序O(n log n)
基数排序O(n)
希尔排序O(n^1.25)
查找
二分查找 （有序）
这些算法的思想的在这不做详细的介绍了：（但这些基础的排序很重要也很基础，可自己查询）
面向对象
思想：封装，继承，多态
面向过程：强调的是功能行为：关注的是解决问题需要哪些步骤
面向对象：将功能封装进对象，强调具备功能的对象。关注的是解决问题需要哪些对象
面向对象是基于面向过程的。面向对象是符合人们思想的思想，可以使开发者有执行者变为指挥者。
可以将复杂的事情简单化
类是对象的抽象
对象<------------------------>类（万物皆对象）
对象是类的实现
类
类：类名，大驼峰原则
属性，成员变量
行为，成员方法 小驼峰原则
名词提炼法
拥有相同（或者相似）属性和行为的对象都可以抽象出一个类
在创建对象时（new），调用构造方法，构造方法会对成员变量初始化（空参构造方法 ，整型0 ，引用为null）。（创建对象时的保存对象地址的变量在栈里）（方法在栈里调用）。如果没有引用的对象（可以被垃圾回收机制回收，匿名对象）
匿名对象的作用：节省代码，节省内存。
应用场所：作为参数传递
数组就是特殊的对象。
一个类型一旦创建出来，就是一个独立的数据类型，在他可见的范围内都是可以使用的，包括内部。
属性：权限
static修饰成员的功能 ：静态成员变量，引用可以调用静态（推荐使用类名调用）类名无法调用非静态的属性；非静态的成员变量只能用引用调用。
总结成员变量的特点:
1.在创建对象的时候会赋默认值
2.可以在类中定义变量的时候,直接赋值
3.非静态的成员变量可以在除了static修饰的方法外任何地方使用.
成员变量和局部变量的区别:
1.作用域:成员变量是整个对象.局部变量是从定义开始到所在的函数/if/for结束
2.默认值:成员变量会有默认值,局部变量没有默认值,要想使用必须先赋值
3.释放机制:成员变量跟对象保持一致,通过垃圾回收机制回收,局部变量使用完立即释放
4.存放的位置:成员变量放在堆区中的对象中,局部变量放在栈区中的方法中.
static:这是一个关键字,被static修饰的成员就变成了静态的.具有保值功能
一个类对应一个字节码文件，
静态方法区：类变成一个.class文件，当类中存在静态属性和方法时，静态属性和方法会被复制（从.class文件中）一份放在静态方法区（通常认为静态方法区在方法区的独立空间）对象的堆空间里只存在非静态的方法和属性。
类调用静态属性时，是字节码文件（.class）调用的静态对象（字节码文件是一个对象（特殊对象））。
静态的成员方法和非静态的成员方法优先使用静态的成员方法。效率高，节省内存。除一种（当方法中使用非静态的属性（成员变量），只能是非静态的方法）
工具类：类似工具经常使用的时候，可以用static封装工具类
构造方法：
默认创建无参的构造方法。作用：在对象被创建的时候给属性赋值。
this关键字：
构造方法局部变量和成员变量相同时（就近原则，没有this时），this等于引用值（引用数据类型，等于当前的对象地址）。this（）可以当做构造方法 ；
this的注意点：
1.不能自己调用自己—死循环
2.不能相互调用,死循环
3.this充当构造方法时,必须放在第一行
4.this在作为方法的时候,只能充当构造方法,不能作为其他方法
5.this的使用范围就是当前类的内部
构造代码块：
随着对象的加载而加载，优先于构造方法之前，对象每创建一次执行一次。{}
静态代码块：
父子类静态代码块的加载，父类静态代码块在前。
随着类的加载而加载，优先于main，整个程序执行过程中只执行一次。static{}
封装性：
通过对具体属性的封装实现的，把对成员变量私有话，通过范围修饰词：private，增加安全性，复用性和可读性。
set get (约定规则，统一规范，方便使用)
脏数据：
脏数据:我们把程序中出现的不符合逻辑的数据称为脏数据
原因:让用户直接将数据传给了成员变量
解决:1.不让他直接传值----将成员变量私有化,写一个公共的方法
2.对数据进行过滤,将过滤后的数据交给成员变量
继承：
关键字：extend 继承的源object
功能：减少代码，多态的前提，方便操作，增加复用性，可读性，安全类。
继承当中方法的调用顺序：
首先从自己的方法里找，如果没有，就会从父类开始往上寻找。
重写
（返回值为类型时，可以为父子关系）：从父类继承中的方法中（增加了特殊功能），重写方法的返回值可以与父类的相同，也可以是父类的子类
重载(Overload)
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:
被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
super关键字：
代表的是当前对象的父类，可以调用父类的方法和属性。但是它不是引用数据结构。在子类构造方法中，默认是有super();调用父类的空参构造方法。（new 子类的时候，也创建了父类对象）
final:关键字
可以修饰的内容：
1.类：final修饰的类不能有子类
2.成员变量：final修饰的变量是一个终值，不能再被改变，所以必须赋值。
3.局部变量：被final修饰的局部变量是一个终值，不能被再改变
4.方法：final修饰的方法不允许重写
5.空白final ------（final在定义成员变量的时候，可以在构造方法中赋值（即在定义时可以不赋值，但是在构造方法中必须赋值））
public static void main(String args[]){
}
object：
clone();克隆
（创建对象的四种方式：new ，克隆，反序列化，反射）
1.要想使用clone方法完成克隆,当前类必须实现了Cloneable这个接口
2.要想使用必须要重写这个方法
3.不是所有系统类都实现了他.比如Object,Integer,String等.实现了他的有ArrayList,LinkedList
4.clone没有调用new方法和构造方法.克隆不会调用构造方法，克隆时，根据源对象类型先分配和源对象相同的内存，然后将源对象中的各个域中数据拷贝过来，最后返回对象地址。new时，第1步也是先分配内存，然后调用构造方法初始化数据，最后将对象地址返回，
外界就可以通过这个对象地址(引用)操作此对象。
5.调用clone没有办法实现完全的深拷贝.对于调用clone的对象是深拷贝,但是对于他的成员默认还是浅拷贝,
如果想让成员也深拷贝,就要在重写的clone方法中调用成员的clone方法,依次类推.
equals(object obj);
比较地址。容错处理。（重载，如果俩个重载方法，类型是父子关系，俩个方法都可以执行，存在优先级。）
finalize();
垃圾回收，
getclass();
返回此object的运行时类，字节码文件对象 ,字节码文件对应的类(Class)。字节码文件对象对应字节码文件（.class这个属性也可以获得字节码文件对象）
jvm中类加载器生成字节码文件对象
hashcode();
应用：对象的身份证。
toString():
默认调用（打印报名+@+hash码）
abstract：抽象的
抽象类中可以没有抽象方法；有抽象方法的类一定是抽象类。
继承的子类要么也是抽象类，要么是实现父类的抽象方法。
抽象类不能直接创建对象，必须通过子类实现，所以抽象类一定有子类。
抽象类的作用：
1抽象方法是没有实现的方法，抽象方法类似于规则声明（制定规则），可以制定一批规则。
2.可以节省代码
抽象类是介于接口和类之间。
比较:final,abstract,static,private
abstract（不能直接调方法，必须继承）和final（不能继承，不能重写）和static（类，调用）和private不能共用。
不能与abstract同时存在的关键字
1.final:被final修饰的类不能有子类,方法不能重写,但是abstract必须有子类,必须重写
2.static:修饰的方法可以通过类名调用,abstract必须通过子类实现
3.private:修饰的方法不能重写,abstract必须重写
接口：interface
接口也是抽象的
类<—>类（继承） extends
类<—>接口（实现）implements
成员变量：默认public,final,static（类型）符号常量。
成员方法：默认是public，abstract
单继承，多实现。
接口与接口之间的继承是继承。（接口同名的方法在类中可以实现（接口俩个方法实现没有区别））。
一般父类中放的是主要功能，接口中放的是额外的功能，接口作为父类的补充。
从jdk1.7 开始，以后的接口中可以有方法的实现，但是方法必须使用static或default修饰（接口同名的方法（实现不同方法（也可能是一个实现，一个是抽象的））在类中使用时必须重写（即俩个接口的实现方法都不取，自己实现）
接口的子类重写方法注意事项：
如果一个类实现两个接口，这两个接口同时有相同的抽象方法，在类中只需要重写一次这个方法。
如果接口中有default修饰的方法不需要重写。
如果两个接口里的方法名相同都是default方法，里面的方法体不同，在类中需要重写该方法。
如果两个接口中方法名，参数都相同的方法，一个接口是抽象方法，另一个是default修饰有方法体。这时该类也必须重写该方法。
面向接口编程：一个类声明一个接口（接口暴露，类不暴露实现）
设计模式
设计模式:前人总结出来的对一些常见问题的解决方案,后人直接拿来使用.
常用的设计模式:单例,工厂,代理,适配器,装饰,模板,观察者等,一共有23种
单例模式
分析:
1.我们肯定要建立一个单例类来描述
2.只允许有一个对象
3.全局的访问点:说的就是当前的s----通过static实现的
4.提供出去
5.给大家使用
作用:
1.传值
2.作为全局的访问点.
使用单例传值的好处:
好处:可以让两个对象在完全没有关系的前提下,实现值的传递,降低了耦合性,提高了内聚性
耦合性,内聚性在微观上说:描述的是类与类之间的关系
好处:我们应该尽量提高内聚性,减少耦合性,可以提高程序的健壮性,增加代码的可移植性,方便实现模块儿化编程
如何做到低耦合高内聚?
在处理类与类关系的时候,让类之间的关系越紧密耦合性越高,内聚性越低.反之,关系越松散耦合性越低,内聚性越高.
注意:在单例中一般只有向外提供s的方法是静态的,其他的都是非静态的.
通过static修饰对象名（当对象有被对象名指向时，垃圾回收机制不会清除）长期保存对象（垃圾回收机制）。
单例类的功能，可以将一个类的局部方法变成全局方法，可以传值（减少类和类之间的关系，高内聚（模块之间完成工作），低耦合（模块与模块之间的联系）），建立全局访问点。
饿汉式
final static *** ** = new **();
private 构造()
public static get***Instance()
{return **;}
懒汉式
static *** ;
private 构造()
public static get***Instance{
(if(**==null)
{** = new **()}
return **;)
}
典型单例类runtime()
package com.work.day4;//测试jvm的内存
public class RunTimeTest {
public static void main(String[] args) {
Runtime time=Runtime.getRuntime();
System.out.println(time.freeMemory()/1024./1024.);
System.out.println(time.totalMemory()/1024./1024.);
System.out.println(time.maxMemory()/1024./1024.);
}
}
模板设计模式
适配器设计模式<----httpservlet之前，三个类构成适配器模式，httpservlet,和myservlet使用模板模式
servlet->(实现，重写5个方法)GenervalServlet->（继承，重写需要的方法）HttpServlet->(继承，重写需要的方法)myservlet
多态：
多态:一种事物的多种形态.
前提是：继承。用法：用父类（不一定是直接的）的引用指向子类对象。
实现动态的手段：动态类型，动态绑定，动态加载。
程序运行分成三个阶段:预编译,编译,运行
预编译:程序打开的时候,活儿已经干完了.(预处理命令 #define)
编译:从打开程序开始到点击左上角的三角之前—只能识别前面的引用类型,不会识别后面的对象
运行:从点击三角开始—真正的识别对象,对象开始干活儿
多态：我们在编译阶段不能确定具体的对象类型，只有运行阶段才知道干活的对象
object ：动态类型 动态绑定：（库运行时，确定库的内容）
总结:优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,不用再创建新的方法.
缺点:只能直接调用父类有的方法,不能直接调用子类特有的方法.
环境：：多态的环境下，说向上转型，向下转型。
注意:是在多态的前提下再说向上转型,向下转型.
向上转型:相当于是自动类型转换.多态本身就是向上转型.
作用:实现多态
向下转型:相当于强制类型转换
作用:解决多态中无法调用子类特有属性的缺点.
运算符：instanceof （使用前提：前后必须有关系）
原理说明：确定当前的对象是否后面的类和子类的对象，是返回true，不是返回false
作用：容错处理，增加用户体验
多态下成员的使用： ！！！！！！方法相同编译看父类，运行看子类
public static void main(String[] args) {
/*
* 继承
*/
Zi zi = new Zi();
zi.show();
zi.eat();
System.out.println(zi.age);//10,继承中子类与父类出现同名的属性,父类的会被覆盖掉
//多态
/*
* 当父类与子类有同名属性或方法时
* 成员变量:编译的时候能不能访问看父类,运行的时候也看父类
* 成员方法:编译的时候能不能访问看父类,运行的时候看子类
* 静态成员方法:编译运行都看父类
*/
Fu fu = new Zi();
System.out.println(fu.age);
fu.show();
}
当父类与子类有同名的方法或属性时：（多态）
成员变量：编译的时候能不能访问看父类，运行的时候也看父类
成员方法：编译的时候能不能访问看父类，运行的时候看子类
静态成员方法：编译的时候能不能访问看父类，运行的时候也看父类
内部类：
内部类：定义在一个类的内部的类，内部类的地位与外部类的成员变量，成员方法平等。内部类也可以看做是外部类的成员。
public class Demo14 {
public static void main(String[] args) {
Outer outer = new Outer();
outer.age = 10;
//调用内部类成员的方式
//两种
//第一种:借助于外部类的方法实现
outer.show();
//第二种:直接在这里调用
//引用:外部类.内部类
//构成:外部类对象的引用.new 内部类的构造方法
Outer.Inner inner = outer.new Inner();
inner.eat();
}
}
class Outer{
int age;
//内部类
class Inner{
int height;
public void eat() {
System.out.println("eat");
}
}
public void show() {
System.out.println("show");
Inner inner = new Inner();
inner.eat();
}
}
内部类：间接使用多继承
class A1{
}
class B1{
}
//说明功能
//我们可以通过内部类让java间接实现多继承
class X extends A1{
class Y extends B1{
}
}
局部内部类：
定义：定义在一个类的方法里的类，
作用：功能私有化，增加代码的可读性和可操作性。
局部内部类:定义在一个类方法中的类
- 作用范围:从定义开始到当前的方法结束
- 了解:局部内部类所在的方法中局部变量的使用.
- 局部变量的作用域:定义变量开始到函数结束
final:被final修饰的变量会被放在常量区,而常量区的值存在的时间要大于局部变量所在的方法,相当于从原来的基础上扩大了作用域
- 原理:
- 当方法中同时存在局部内部类与成员变量时,成员变量的使用范围就会从原来的基础上进行扩大.
- 原因:在当前的情况下,程序会默认让final去修饰height.所以当局部变量所在的方法结束的时候,变量没有被释放,保存的值还在.
- 关于变量前面的final:
- 前提:变量必须与局部内部类同时存在.并且在局部内部类中使用了当前的局部变量
- 在jdk1.7之前要想保住局部变量的值,要手动添加final
- 在jdk1.7之后,java的内部机制已经在变量的前面默认添加了final
静态内部类：
静态内部类不一定有静态方法，有静态方法的一定是静态内部类。
public class Demo17 {
public static void main(String[] args) {
// Out out = new Out();
// Out.Inn inn = out.new Inn();
//创建静态内部类对象
//构成: new + 外部类名字.内部类的构造方法
Out.Inn inn = new Out.Inn();
//调用方法
inn.play();
//调用静态方法
// inn.show();
Out.Inn.show();
}
}
匿名内部类：
定义：定义在一个类方法中的
匿名内部类(对象):定义在一个类方法中的匿名子类对象,属于局部内部类
- 匿名子类对象:
- 匿名内部类对象:
- 创建匿名内部类对象注意点:1.匿名内部类对象必须有父类或者父接口
- 匿名内部类对象的作用:
- 1.当只用到当前子类的一个实例对象的时候,定义好马上使用
- 2.当不好起名字的时候
- 3.可以更好的定义运行时的回调(知道即可)
- 内部类的作用:
- 1.间接实现了多继承
- 2.方便定义
- 3.只有外部类可以访问创建的内部类的属性和方法,包括私有方法
- 4.同一个包中其他的类不可见,有了很好的封装性
//匿名内部类作为参数
public void canShuTest1() {
System.out.println(
new Animal() {
public void eat() {
// TODO Auto-generated method stub
super.eat();
}
@Override
public String toString() {
return "haha";
}
}
);
常用类
Math
package com.ali.test;
import java.util.Random;
/*
* Math:装的是用于数学的计算方法
*/
public class Demo13 {
public static void main(String[] args) {
System.out.println(java.lang.Math.abs(-10));//绝对值
System.out.println(java.lang.Math.cos(3.14159));//三角余弦
System.out.println(java.lang.Math.ceil(3.4));//向上取整
System.out.println(java.lang.Math.floor(3.4));//向下取整
System.out.println(java.lang.Math.random());//随机数 [0,1.0)
//求[0,10)之间的整数
System.out.println((int)java.lang.Math.floor(java.lang.Math.random()*10));
//Random类
//求[0,10)之间的整数
Random random = new Random();
System.out.println(java.lang.Math.abs(random.nextInt()%10));
System.out.println(random.nextInt(10));//直接获取的是[0,10)之间的数
}
}
BigInteger(嵌套了math，可以直接使用math的方法)
包装类
包装类：专门将简单数据类型的数据类型，形成的对应的类
简单数据类型 包装类
byte Byte
short Short
int Integer
long Long
char Character
如果想字符串转换数字，必须是数值型字符串。
简单数据类型->包装类（装箱 Integer integer1=new Integer(5)）;
包装类->简单数据类型（拆箱 int value = integer1.tovlaue）
jdk1.5开始可以实现自动装箱，拆箱。
/*
* 包装类:专门将简单数据类型的数据进行封装,形成的对应的类.
* 简单数据类型 包装类
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* boolean Boolean
* char Character
*/
public class Demo10 {
public static void main(String[] args) {
// 基本类型转成字符串类型
// static String Integer.toString(int i)
// static String Double.toString(double d)
String value1 = Integer.toString(12);
System.out.println(value1+2);
// 字符串类型转基本类型
// int Integer.parseInt("23")
// double Double.parseDouble("3.45")
//注意:这里的字符串必须是数值型的字符串
int a = Integer.parseInt("234");
System.out.println(a+2);
//
// 把十进制转成其它进制
// Integer.toHexString() 十六进制
// Integer.toOctalString() 八进制
// Integer.toBinaryString() 二进制
System.out.println(Integer.toHexString(10));
System.out.println(Integer.toOctalString(10));
System.out.println(Integer.toBinaryString(10));
// 把其它进制转十进制
// Integer.parseInt(数据,进制)
System.out.println(Integer.parseInt("10",2));
}
}
//注意点:在一个字节范围内前面定义好的,后面再定义,直接使用前面的.
// Integer integer4 = 100;
// Integer integer5 = 100;
// System.out.println(integer4 == integer5);//true
//如果超过了一个字节的范围,就认为是两个数,要独立占用两块儿内存空间.
Integer integer4 = 1000;
Integer integer5 = 1000;
System.out.println(integer4 == integer5);//false
即在包装类中，如果数据比较小（一个字节），认为是一个对象（值相同，即使new了俩个对象。）
枚举
也是一个特殊的类(创建对象，调用方法)
package com.ali.test;
/*
* 枚举
* 默认对应的是数字.数字从0开始计数
* 枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。
* 枚举在曰常生活中很常见，例如一个人的性别只能是“男”或者“女”，一周的星期只能是 7 天中的一个等。
* 类似这种当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型。
在 JDK 1.5 之前没有枚举类型，那时候一般用接口常量来替代。
而使用 Java 枚举类型 enum 可以更贴近地表示这种常量。
*/
enum EnumTest{
First,
Second,
Third,
Fourth,
Fifth,
Sixth
}
public class Demo12 {
public static void main(String[] args) {
EnumTest test = EnumTest.Fifth;
System.out.println(test.compareTo(EnumTest.First));
switch (test.compareTo(EnumTest.First)) {
case -1:
System.out.println("不相等");
break;
case 0:
System.out.println("相等");
break;
case 4:
System.out.println("不相等");
break;
default:
System.out.println("hah");
break;
}
System.out.println(EnumTest.First);
System.out.println(test.getDeclaringClass().getName());//字节码文件对象
System.out.println(test.name());
System.out.println(test.toString());
System.out.println(test.ordinal());
}
}
异常
定义：程序当中出现的不正常的情况;
异常的由来：程序在运行时出现了不正常的情况，java提取了对应的属性，名字，原因等，形成异常对象，进而形成了各种异常类
异常的分类：（throwable）
1.Error(错误)：运行中出现的严重错误，不需要我们进行更改
2.Exception：运行中出现的不严重的错误，我们可以尝试去更改。
Exception:分类
第一种分类：系统异常，系统提前定义好的，我们直接使用
自定义异常：需要自己定义
第二种分类：编译阶段抛出的异常：
运行阶段抛出的异常：大部分使用的异常。(在写代码的时候不需要的处理，手动避免)
运行阶段出现的错误：会在此处产生一个异常对象，如果此处没有处理异常的机制（能力），能继续往上抛，一直的到jvm，jvm会报错。
public class Demo1 {
public static void main(String[] args) {//4.这里也没有处理异常的能力,继续往上抛,抛给JVM.
//JVM会调用异常类的打印方法,将异常的信息打印到控制台
Math math = new Math();
int value = math.div(3, 0);//3.这里也没有处理异常的能力,继续往上抛
System.out.println(value);
}
}
class Math{
public int div(int a,int b) {//2.div方法也没有处理异常的能力,继续往上抛
return a/b;//1.会自动生成一个异常类对象(new ArithmeticException()) ,这里没有打印的能力,程序会将异常抛出,抛给
//他所在的方法
}
}
异常的特点：程序出现异常的时候，会打印异常的信息并中断程序的进行，所以当有多个异常同时出现的时候,默认只能执行第一个.
try catch
catch会对try里面的代码进行监听，如果try里面的代码没有异常，catch不会执行，会直接执行后面的代码
如果try里面的代码发生了异常，catch会立刻捕获（效果：try里面的代码会立刻中断，直接执行catch）
try{
可能发生异常的代码
}catch(Exception e){ //捕获异常 e就是要捕获的异常
对当前异常的处理
}
try {
int value = math.div(3, 0);//3.这里也没有处理异常的能力,继续往上抛
//注意:只要try内部的代码发生了异常,catch会立刻捕获异常,马上执行catch,所以发生异常后的代码不会执行.
//只有try里面的代码没有发生异常,这里的代码才能执行
System.out.println("haha:"+value);
}catch (Exception e) {//e = new ArithmeticException() 多态
//对异常进行处理
//e.printStackTrace();//打印异常的位置,原因,名字
//System.out.println(e.getMessage());//打印原因
System.out.println(e.toString());//打印原因,名字
}
多重处理（多个异常）：try catch catch finally//必须执行的操作（例如：关闭数据库）：主要用于资源的释放等。
catch会对try里面的代码进行监听,如果try里面的代码没有发生异常,catch不会执行,会直接执行后面的代码.
如果try里面的代码发生了异常,catch会立刻捕获(效果:try里面的代码会立刻终端,直接执行catch)
try{
可能发生异常的代码
}catch(异常一 e){ //捕获异常 e就是要捕获的异常
对当前异常的处理
}catch(异常二 e){ //捕获异常 e就是要捕获的异常
对当前异常的处理
}catch(Exception e){ //捕获异常 e就是要捕获的异常
对当前异常的处理
}
（return 结束不了，finally还能执行）
System.exit(0)?/退出程序，
finally不能执行了
这个结构跟异常没有关系
try{
获取资源
}finally{
释放资源
}
自定义异常：常见：订单异常，用户异常，素数异常
什么是自定义异常:自己定义的异常类,由于Exception已经有了异常的基本功能,所以一般写的是他的子类
为什么要自定义异常?
系统没有定义的异常需要我们自己来定义,我们要解决的是系统没有解决的问题
分类:
编译异常:发生在编译阶段.—对应的异常是除了RumtimeException之外的所有异常
特点:对异常进行处理的所有工作都要我们手动完成
运行时异常:发生在运行阶段.—RumtimeException
特点:所有的工作我们都可以不管
常见的自定义异常:订单异常 用户异常 负数异常
以负数异常为例:
对于编译异常需要我们进行处理的有:
异常类的创建----FuShuException
异常对象的创建—应该是在发生异常的位置
异常对象的抛出—throw
异常的声明(我们要给可能发生异常的方法进行异常的声明)----throws
作用:告诉别人我有可能发生异常
package com.ali.test;
//为了解释FuShuException构造方法中的参数如何在打印方法中显示.
public class Demo7 {
public static void main(String[] args) {
Teacher teacher = new Teacher("除数为负数了");
teacher.printStackTrace();
}
}
class Person{//相当于Exception
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String message) {
super();
this.message = message;
}
public void printStackTrace() {
System.out.println(this.getMessage());
}
}
//相当于FuShuException
class Teacher extends Person{
public Teacher() {
}
public Teacher(String message) {
super(message);
}
}
特点:所有的工作我们都可以不管
常见的自定义异常:订单异常 用户异常 负数异常
以负数异常为例:
对于编译异常需要我们进行处理的有:
异常类的创建----FuShuException
异常对象的创建—应该是在发生异常的位置
异常对象的抛出—throw
异常的声明(我们要给可能发生异常的方法进行异常的声明)----throws
作用:告诉别人我有可能发生异常
package com.ali.test;
//为了解释FuShuException构造方法中的参数如何在打印方法中显示.
public class Demo7 {
public static void main(String[] args) {
Teacher teacher = new Teacher("除数为负数了");
teacher.printStackTrace();
}
}
class Person{//相当于Exception
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String message) {
super();
this.message = message;
}
public void printStackTrace() {
System.out.println(this.getMessage());
}
}
//相当于FuShuException
class Teacher extends Person{
public Teacher() {
}
public Teacher(String message) {
super(message);
}
}