常用类 枚举 异常 Math tcp与udp

常用类 枚举 异常  Math tcp与udp

异常：程序中出想不正常的情况。

因为面向对象，所以JAVA把异常处理也进行封装，

- throwable :

Error:运行中出现的严重错误，不需要我们进行更改。

Exception:运行中的不严重的错误，我们可以尝试解决。

Exception :

编译时异常：

运行时异常：RuntimeException

系统异常：已存在的;如数组越界

自定义异常：自己写

原理：

1. 在异常地方，生成异常类对象，但这里没有处理异常的能力，往上抛。当到了main时，也没有处理异常的能力，也继续往上抛，抛给JVM。此时JVM会调用异常类，将异常的信息打印。

2. 当程序中有多个异常的时候，只执行第一个，因为程序中断，

处理异常的手段

当个异常:

1. catch会对try里面的代码进行监听，如果try里面的代码发生了异常，catch会立即捕获（处理之后，会执行后续的代码）

2.代码示例：

try{

可能发生异常的代码

}catch(Exception  e){ //捕获异常    e就是要捕获的异常

对当前异常的处理

}

public class Demo3 {

public static void main(String[] args) {

Math1 math = new Math1();

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());//打印原因,名字

}

System.out.println(“go on”);

}

}

class Math1{

public int div(int a,int b) {//2.div方法也没有处理异常的能力,继续往上抛

return a/b;//1.会自动生成一个异常类对象(new ArithmeticException()) ,这里没有打印的能力,程序会将异常抛出,抛给

//他所在的方法

}

}

多个异常：

1.try–catch–catch:

2.代码示例：

try{

可能发生异常的代码

}catch(异常一  e){ //捕获异常    e就是要捕获的异常

对当前异常的处理

}catch(异常二  e){ //捕获异常    e就是要捕获的异常

对当前异常的处理

}catch(Exception  e){ //捕获异常    e就是要捕获的异常

对当前异常的处理

}

问题:为什么不直接在catch里面直接写Exception e?

因为捕获异常要进行处理，不同的异常会有不同的处理方式,所以Exception必须加在最后。

finally:必须执行的代码：

1.当你把函数结束时（return）,finally还会执行。

2.system.exit(0);,finally不会执行。

区别 try-fianlly:这个结构跟异常没有关系

try{

获取资源

}finally{

释放资源

}

自定义异常：（本质就时if判断）；由于Exception已经有了异常的基本功能，所以一般写的是他的子类。（编译时用的最多）

- 步骤：

1.创建异常类

2.异常对象的创建

3.异常对象的抛出（throw）创建抛出对象，发生异常的代码

4.异常的声明：（throws）可能发生异常 ，在方法中声明异常

class FuShuException extends Exception{

public FuShuException() {

// TODO Auto-generated constructor stub

}

public FuShuException(String message) {

//这行代码必须写

super(message);

}

}

public class Demo6 {

public static void main(String[] args) //throws FuShuException

{

Math4 math4 = new Math4();

//第一种方式:继续向上抛,最后交给JVM

//math4.div(3, -2);

//第二种:tryCatch

try {

math4.div(3, -2);

} catch (Exception e) {

e.printStackTrace();

}

}

}

class Math4{

//声明异常,告诉别人我是有可能发生这个异常.

//当需要声明多个异常的时候,直接用,隔开

public int div(int a,int b) throws FuShuException

{

if (b < 0) {

throw new FuShuException(“除数为负数了”);

}

return a/b;

}

}

为了解释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);

}

}

调用异常方法时：可以声明异常（throws），也可以捕获异常(try-catch)

模板设计模式：（基于抽象类的设计模式）把功能分为2块，一块 是确定的，另一块 是不确定的，将确定的部分交给当前类实现，将不确定的部分交给子类实现.子类实现的结果又会反过来影响确定部分的功能。

原理：在模板方法中定义一个算法的步骤，并允许子类为一个或多个步骤提供具体实现

public class Demo9 {

public static void main(String[] args) {

//测试

Zi zi = new Zi();

long value = zi.getTime();

System.out.println(value);

}

}

abstract class Fu{

abstract public void function();

public long getTime() {

//开始时间

long startTime = System.nanoTime();//获取的系统时间,单位纳秒

//程序运行的时间

function();

//结束时间

long endTime = System.nanoTime();

return endTime-startTime;

}

}

class Zi extends Fu{

public void function() {

for (int i = 0; i < 10; i++) {

System.out.println(“i:”+i);

}

}

}

get/post:get–在网站上会有输入的名字；post----不会有名字

包装类 父类就是Number

为什么要有包装类？

1.为了集合的使用，因为集合存储是对象。

2.方便进行进制转换，        //Integer.parseInt(数据,进制)

3.基本数据类型和字符串转换

拆箱和装箱：

1.拆箱：从包装类对象中取出简单数据类型

int value1 = integer1.intValue();

float value2 = integer1.floatValue();

2.装箱：简单数据类型转换程对应的对象

int a = 5;

Integer integer1 = new Integer(a);

从jdk1.5开始可以实现自动拆箱,装箱

Integer integer2 = new Integer(4);

Integer integer3 = integer2+2;//进行了自动拆箱,取出了4,然后跟2相加得到6.又进行的自动装箱

System.out.println(integer3);

注意1：在一个字节范围内前面定义好的,后面再定义,直接使用前面的

Integer integer4 = 100;

Integer integer5 = 100;

System.out.println(integer4 == integer5);//true

注意2：如果超过了一个字节的范围,就认为是两个数,要独立占用两块儿内存空间.

Integer integer4 = 1000;

Integer integer5 = 1000;

System.out.println(integer4 == integer5);//false

枚举 enum

- 默认对应的是数字，数字从0开始计数

举例：

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());

}

}

JDK1.5之前没有没有枚举类型

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)之间的数

}

}

##  TCP传输的是流 安全性高，面向连接，UDP 面向无连接，安全性低，传输的是包

应用层，表示层，会话层,传输层,网络层,数据链路层,物理层

数据链路层:它定义了在单个链路上如何传输数据。这些协议与被讨论的各种介质有关。示例：ATM，FDDI等。

传输层:这层的功能包括是否选择差错恢复协议还是无差错恢复协议，及在同一主机上对不同应用的数据流的输入进行复用，还包括对收到的顺序不对的数据包的重新排序功能。示例：TCP，UDP，SPX。