0%

6.15~6.27

发表于 更新于 分类于 阅读次数：
本文字数： 16k 阅读时长 ≈ 14 分钟

2017年6月29日 上午9:08

1.文档注释
接口，dao,biz,service中类的说明方法及方法写文档注释
2.java的八大数据基本数据类型
3.num + num + String =
String + num + num =
num+char=num
4.命名首字符：字符 下划线 $
不可以关键字 保留字 %
5.定义变量的两种形式
========================6 16 数据类型 =======================
1.类型转换，向大的类型转换
char sex = 12 + ‘c’;1.7不会报错，但是不能超过char的容量和ASSIC 

int  age = 20 ;
char sex = age + ‘c';会报错

当大的类型转小的类型，要强制转换

2.long 型(64) l or L
short(16)
3.int age = (int)1234566789;报错 不能抢转
4.boolean yes = 1 ; 报错
5.运算优先级 算数 比较 || ！
6.int n1=1;
int n2 = 01;八进制
int n3 = 0x1;16进制
7.String name1 = “abc”;
String name2 = “abc”;相等 这里的“abc”是把上一句定义的额拿出来用

String name3 = new String("abc");
String name4 = new String("abc"); 不相等

8.流程图
9.jdk1.6中switch不可以字符串 ，double 都不支持
条件-确定区间的开头，break决定退出
不要少break
于if的不同：
switch 可以转换成if ，但是if不一定能转成switch
switch 有类型的限制，而if没有
10.循环的流程图

=======================6.19 循环==========================
1.for(;;){}
2.for(;;i++,j++) 从左到右
3.for(){
switch(){
case 11:
;
continue;作用和break一样
}
}
4.while 里面不能用continue
5.记录错误
6.
int count=0; 第1行
int x[ ] = new int[10]; 第2行
for(int i = 0; i < 5;i++){ 第3行
count++; 第4行
i++; 第5行
} 第6行
System.out.println(x[5]); 第7行

  1. int n;
    double s;
    s=1.0;
    for(n=10;n>1;n–){
    s=s+1.0/n;
    }
    System.out.println(s);

  2. String s;
    System.out.println(s);
    局部变量初始化
    =========================6.20==========================

  3. 数组长度固定，不是基本类型，是引用类型。
    数组会赋初值

  4. 两种赋值方式
    2.1int num[]= new int[10];必须说明长度 int初始化为0

    2.2
    int []num;
    num=new int[5]

    2.3
    int num[]=new int[]{1,2,34}
    String str[]= new String[]{“”,””} 赋值空字符串

    错的
    String str[] = new String[];
    str[]={}这个必须写成两行，不能单独写{}

    String classes[] = new String[3]{“c#”,”java”,”php”};长度不能定义两次

3.异常yarrayIndexOutOFBoundsException为运行时异常
4.arrays.sort(数组名)
正序 逆序
5.求最大值 最小值时 要先获取值完之后 才假设最大值and最小值，否则会出错。
他会将你附的那个值也参与比大小。
index = 0 ;
输入；
比较；
如果这里的输入全是负值，那么最大值就是一开始附的0

6.if (a = b) 编译错
7.String s;
System.out.println(s); 编译错
8.\r 光标最前
9.思路：因为层数是确定的，所以所有的规律都要找于层数的关系，也就是与i的关系【找去已知条件的关系】

==================== ==6.21 ==========================
1.成员变量 局部变量的位置
2.封装 继承 多态的english
encapsulation 封装
Inheritance 继承
Polymorphism 多态
3.及时保存
4.oo Object Oriented
5.return;
6. Admin admin[] = new Admin[10];
for(int i = 0;i < admin.length;i++){
admin[i]= new Admin();
}
单独第一句会报空指针异常，因为初始值为null
7.public String toString()重写，在syso输出对象的时候为toString（）方法内容。如果没有重写，那么输出对象的类名和地址等
8.同一个包里的class不用import直接就可以生成对象
9.实例方法=必须通过对象来调用的方法 实例=对象
10。实例 = 对象 抽象=类 对象和类的关系
11.实例方法在一个类中可以直接调用 不用this就可以
而，不同类之间的调用必须先声明对象，在调用
12.不能return 两个变量。
return a,b;错
13.不能函数之外直接写逻辑，逻辑必须写在函数中
14.
String.valueOf(); 其他所有类型转 String
str.toCharArray(); str转char[]
15. int num[] = {1,2,3,4,5} 对的
16.字符转数字

1
2
3
4
5
6
Scanner scan = new Scanner(System.in);
String  string = scan.next();
char ch[]= string.toCharArray();
for(int i  = 0 ;i < ch.length;i++){
	System.out.println(ch[i]-48);
}
字符1 -48 = 数字1

========================6.22=========================
1.int num[][]= new int[3][];
2.scan.nextLine() scan.next()的区别
can.nextLine():读的是行为单位
scan.next()：一空白符为单位
3.String 于 普通对象的对比

1
2
3
4
5
6
7
8
9
10
11
12
		String string = new String();
		System.out.println(string);
//		System.out.println(string.equals(""));
		
		StudentBiz stu1 = new StudentBiz();
		System.out.println(stu1);
		
		String str[]= new String[10];
		System.out.println(str[0]);
		
		StudentBiz stu2[] = new StudentBiz[10];
		System.out.println(stu2[0]);
输出：

    StudentBiz@6f94fa3e
    null
    null

4.null是没有空间的
5.java中的包名小写 + 不以.为开头 + ；
6. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Student student  = new Student();
Student stu[] = new Student[3];
Scanner scanner = new Scanner(System.in);
for(int i = 0 ;i < 3;i++){
	student.name = scanner.next();
	stu[i]=student;
	System.out.println(stu[i].name);
}

for(int i = 0; i< 3;i++){
	System.out.println(stu[i].name);
}

scanner.close();
解释：真正的空间就一个 new Student();
       其他的 student+stu[] 其实就是一个指针。
        多个指针指向为一个的一个空间，当然会造成所谓的“覆盖”

========================6.23============================
1.String 的使用
java.lang包
String str = “”;长度为0
String str = “ “;长度为1
中文的长度也是1
String类是final类
== 内存池

栈区：编译器自动分配释放
    存放函数值+局部变量
堆：有程序员new分配释放，若程序员不释放，程序结束时os释放

全局区：全局变量+静态变量  放在堆中初始化之后放在一起，没有初始化的放在旁边的一块区域。程序结束后系统释放
文字常量区：“abc”
程序代码区：

equals()的比较原理 一个个字符的比较
== 比较是不是相同的地址，内存的首地址

toLowerCase()
toUpperCase()
equalsIgnoreCase()


A.concat(B);B接到A后面
String s1 = "你好";
String name ="张三";
String sen = s1.concat(name);
；不影响s1的值
s1 = s1.concat(name);
;这个才影响s1的值

提取方法：返回第一个匹配的位置
    indexOf(int ch);
    indexOf(String value);

    lastIndexOf(int ch)
    lastIndexOf(String value)

提取：返回字符串的一部分
    subString(int index);
    subString(int index_start,int index_end);包括start不包括end
    tirm();清楚前后空格，重新产生对象，不影响本身

str.replace()->替换replace

转：
str.valueOf() -> 字符串  -> toCharArray()
                     -> charAt()

2.int num[10];编译出错 说明长度情况下，必须要有指向的内容
3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
	// TODO Auto-generated method stub
	Scanner scan = new Scanner(System.in);
	System.out.println("请输入用户名");
	String str1 = scan.next();
	Verify(str1,str2,str3);
	System.out.println("str1:"+str1);
	
}

public static void Verify(String str1,String str2,String str3){
	str1 = "acb";
	System.out.println("str1:"+str1);
}
请输入用户名
abc
str1:acb
str1:abc

总结：verify（）的参数 就是指针 而不是真正的对象。
    基本类型数组

？4.c++中对象 指针
5.String ,StringBuffer ,StringBuilder
StringBuffer
1. toString();
2. insert();
3. append();
6.String str[] = new String[3]{“1”,”2”,”3”}; 编译错
7.temp = input3.split(‘-‘);错
参数是字符串，而不是字符
总结：看eclipse的提示
8:java string类型最后是没有’\n’的，这与c++不同
9：bat 批处理
？10：在做完项目之后，我们要进行项目总结，自己当初如何分析的，有没有可以改进的地方
？11：面向对象的抽象
？12:设计模式
13:

1
2
3
4
5
6
7
8
9
public Dog(){
	
}//当写了构造方法之后，就得加上空的构造方法了额
public Dog(String name,int health,int love,String dif){
	this.name = name;
	this.health = health;
	this.love = love;
	this.dif = dif;
}//当参数和成员变量同名时，使用this来区分

14：source生成构造方法
15:方法的重载
16： 

1
2
3
4
5
public void print(int a , String b);
public void print(String a,int b);//是重载

public void print(int a ,int b);
public void print(int b,int a);//不是重载
重载的条件
1.同一个类中
2.参数列表不同
3.方法名相同
4.和返回值，访问修饰符无关

override 重写
overload 重载

17：类名不能直接访问成员变量 要写成static
18：static 三种用途
1.属性 在堆中 位置：全局变量+static方法中
2.静态块 常用去提前配置
static {
syso(“*”)
}
3.方法
不能直接访问非静态的方法+成员变量(也不能定义)
可以通过 对象. 去访问

public void play(){
    static int local = 5;    错
}

19：override：覆写，”实现类”实现了”接口”定义的方法
overwrite：重写，”子类”重新实现了”父类”定义的方法
overload：重载

20：
封装步骤
1.private
2.getter setter方法
3.写逻辑

21:option + command + s = gettter setter
private int a = 0;

public int getA() {
    return a;
}
public void setA(int a) {
    this.a = a;
}

22:this() 调用构造方法 必须放类的第一句

========================6.23=======================
1.
public static void main(String[] args) {
String str=null;
str.concat(“abc”);
str.concat(“def”);
System.out.println(str);
}
A. 输出：null
B. 输出：abcdef
C. 编译错误
D. 运行时出现异常

总结：现在运行时异常一共有两种：
    1.数组越界 2.对象空间为null进行.操作的方法

2.int num = (int)(Math.random()100);
int num = (int)Math.random()100;
总结：强制转换的优先级高
第二个是先对Math.random 强制转化成int 这就造成了num的值一定为0
3.char c = 100;
举例：

1
2
3
4
5
6
7
char x= 100;	
System.out.println(x);
System.out.println(x + 0);

int y = 100;
System.out.println(y);
System.out.println((char)y);
输出：
    d
    100
    100
    d

总结：他们内存本质是一样的，唯二的区别是
     1.int是16位，char是8位
     2.输出时的方式不同

4.错题
8) 在Java语言的控制结构中，break语句是经常用到的语句。下面一段代码中break语句起到（A，c）的作用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int pointer = 0;
while (pointer <= 10) {
    switch (pointer % 3) {
    case 1:
        pointer += 1;
        break;
    case 2:
        pointer += 2;
        break;
    default:
        pointer += 3;
        break;
    }
}
    A.    结束当次循环，使控制权直接转移到控制循环的条件表达式
    B.    从嵌套循环内部跳出最里面的循环
    C.    终止switch语句的语句序列，提高switch-case语句性能
    D.    退出循环
总结：少选了

19)    给定一个Java程序的代码如下所示，则编译运行后，输出结果是（ A）。
1
2
3
4
5
6
7
8
9
10
public class Test {
    int count = 9;
    public void count() {
        System.out.println("count=" + count++);
    }
    public static void main(String args[]) {
        new Test().count();
        new Test().count();
    }
}
    A.    count=9
        count=9
    B.    count=10
        count=9
    C.    count=10
        count=10
    D.    count=9
        count=10
总结：注意到这里是声明了两个互补干扰的对象，他们之间是没有影响的

20)    有关Java中的类和对象，以下说法错误的是（ b）。
    A.    同一个类的所有对象都拥有相同的特征和行为
    B.    类和对象一样，只是说法不同
    C.    对象是具有属性和行为的实体
    D.    类规定了对象拥有的特征和行为
总结：我以为的是:不同对象之间相同的属性但是有不同的值，也算拥有不同的特征

22)    在Java语言中，有如下代码：（b,d）
1
2
3
4
5
6
7
8
9
10
11
switch(x) {
    case 100 :
        System.out.println("One hundred");
        break;
    case 200 :              
        System.out.println("Two hundred");                 
        break;
    case 300 :
        System.out.println( "Three hundred");
        break;
}
    下列x的定义中，（ ）可以使得上段代码编译通过。
        A.    double x = 100;
        B.    char x = 100;
        C.    String x = "100";
        D.    int x = 100;
总结：在switch中 case中的条件类型只能有一种，不能同时又int 或者 String
      但是 int和char是可以同时出现，因为char本身就是int，只是换了一种表现形式

5.ASCII 有意义的范围是0-127
128-255 也能定义，但输出后像乱码

举例：
1
2
3
char x= 230;	
System.out.println(x);
System.out.println(x + 0);
输出
æ
230

====================6.26 继承 重载 多态======================

  1. super()
    super(a,b) 调用带参构造
    super.属性
    super.方法

  2. 先执行父类构造，再执行子类构造

  3. debug 鼠标放到变量上

  4. 无参构造
    子类默认调用父类的无参构造，当父类无参构造不存在时，子类不会自动调用父类的有参构造

  5. super不在过构造方法时，可以不放在第一行

  6. pet dog = new dog();
    dog.print();默认调用子类的print方法（print方法，子类父类中都有）

    pet dog = new dog();
    dog.method();不能调用子类特有方法（method 只有子类中有）

  7. 子类不可以调用父类的有：
    private
    构造方法
    不在同一个包
    默认类型的成员

  8. 修饰符：

    本类 同包 子类 其他（不同包）            唯一的标准

    private 🐶 是否在 同一个类
    frendly 🐶 是否在 同包 默认的
    protect 🐶 是否 继承
    public 🐶 都行

9.包名不能建成package
10.不同包继承时，父类不能放在默认的包中（default package中）
11.super总结

1
2
3
4
5
6
7
8
9
10
11
12
super只能在写方法中
package package1;

import package2.A;

public class B extends A {
	
	//super.a =2;//Syntax error on token "{", { expected after this token
	public B(){
		super.a =2;
	}
}
super不在过构造方法时，可以不放在第一行

super不能访问父类private成员


super()
super(a,b) 调用带参构造
super.属性
super.方法

12.❤️❤️❤️❤️❤️❤️❤️❤️重写 重载 对比
重写
1.重写
2.类型相同/父类返回类型的子类 + 修饰符只能扩大，不能缩小 + 方法名，参数列表相同
3.构造方法不能重写

重载的条件
1.同一个类中
2.参数列表不同
3.方法名相同
4.和返回值，访问修饰符无关
13.
抽象类不能实例化 — 因为没有意义
Pet pet = new Dog() pet是abstract
是对的 这只是一个指针指向 没有分配空间进行实例化

抽象类中可以有0个或者多个抽象方法  
子类中，抽象方法在子类中必须实现

14.final
方法 重写
变量属性 修改 （当变量为对象时，final对象不可以=new Object()，但是仍然可以改变这个对象的属性）
类 继承
15.this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//父类
package package3;

public class Car {
	private int site = 4; //座位数 
	
	Car(){
		System.out.println ("载客量是"+site+"人");
	}
	public void setSite(int site){ 
		this.site = site;
	}
	void print(){
		System.out.print("载客量是"+this.site+"人"); 
	}
}

//子类
package package3;

public class Bus extends Car {
	Bus(int site){
		//这三个的输出结果是一样的
		//this.setSite(site); 
		//super.setSite(site);
		setSite(site);
	}
//	public void setSite(int site){ 
//		super.site = site;
//		//this.site = site;
//	}
	public void show(){
		System.out.println("Bus_print");
	}
}

//测试类
package package3;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Bus bus = new Bus(20);
		bus.print();

	}

}
总结：
       1. 在继承中，如果子类没有重写父类的方法，那么子类是调用的是父类的方法
       2. ❤️这里的调用，是在父类中执行，而不是在子类中执行（原来理解的是在子类中执行）
       3. 即使，这三个的输出结果是一样的
       this.setSite(site); 
       super.setSite(site);
       setSite(site);

       4. 继承不是拥有这项技能，而是能让父类帮你干，你自己其实不会。

  1. super.name

  2. 用构造方法不一定会生成对象
    eg：pet pet = new dog（）
    这调用了父类的构造方法，也调用了子类的构造方法，但是，但是只生成了子类对象

  3. 多态：同一个引用类型，使用不同的实例而执行不同操作

    父类存在的地方一般都能使用子类代替

    要素：

    1.子类重写父类分方法
2.使用父类的类型

    使用的地方：

    1.方法参数
2.方法返回值

  4. ❤️Pet 是一个abstract类，他不能new一个对象，但是却可以调用方法pet.eat();

  5. pet instanceof Dog
    instanceof 使用：对象.instanceof(父类/接口)

    Dog dog = （Dog）pet;强制转换
    (Dog)pet.dark();这的是错的，之后转换了之后才可以进行特有dog方法的调用

  6. ❤
    MotoVehicle moto[] =new MotoVehicle[4];
    这个MotoVehicle是abstract类，但是能用new，这个例子就充分的说明了，new ！= 分配空间。
    在这里，他仅仅说明了moto[]的长度

    对象数组的初始化方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    第一种：
    MotoVehicle moto[] = new MotoVehicle[]{
    		new Car(1,"宝马1","红色",1000,20),
    		new Car(2,"宝马2","红色",1000,20),
    		new Bus(3,"金龙1","绿色",1000,"x"),
    		new Bus(3,"金龙2","绿色",1000,"xx"),
    		new Bus(5,"金龙3","绿色",1000,"xxx"),
    		new Ka(6,"Ka1","兰色",1000,100)
    };
    1
    2
    3
    4
    5

    第二种：
    for(int i = 0 ;i < n;i++){
    	moto[i]= new Car(****);//只能生成一种Car类型的
    }

22.abstract的作用
1.对于架构设计者，他可以写好abstract类 ，以及其中的abstract方法，这就规定了这个类的子类必须要实现这个方法
2.abstract的方法其实还是可以调用的，于instanceof+重写（重写不仅仅用于abstract），可以实现工厂模式+抽象工厂模式——也就有了扩展性

23.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
类B
package package6;

public class B extends A{
	int a;
	public void show(){
		a = 2;
		System.err.println(this.a);
		System.err.println(super.a);
	}
}

类A
package package6;

public class A {
	int a;
}

Test类
package package6;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		B b = new B();
		b.show();
	}

}
输出结果
2
0

=================6.27接口+ 异常================
1.接口
接口不能实例化
实现类必须实现接口的所有方法
变量都是静态变量
现类可以实现多个接口

2.interface implements
3.interface的默认
方法：public abstract void service(); 不能用static
变量：public staic final double PI = 3.14;
4.❤️实例化两种 (UDisk implememts UsbInterface)
UDisk u = new UDisk();
UsbInterface u2 = new UDisk();

5.❤️接口实现方式和设计模式的不同

在设计模式中，door是雇主，而lock是雇员，他们两个都是抽象类（可以方便的横向扩展）,door中有lock的对象（仍然是两个对象）
但是在接口中,没lock的对象，而是直接拿到了lock的方法，两个对象合二为一（合二为一为重点）


总结：
    设计模式是类，对象之间相互组合，至少也有两个对象（把功能分配给不同的对象去完成）
    而抽象和接口，本质是把一个类的方法进行拆分，分别放在抽象类和接口类中，让其他类也可以用（把功能分成方法集，方便其他类用)

接口改成类后更加灵活：
当把一个接口A写成类A，B不是通过implement来使用，而是在类B中声明一个new A对象，
这种改法使得B类可以更加灵活，因为可以通过更改A的实例，让B有新的功能。
相同的功能，如果更改在B中更改A的接口方法，那么就必须去更改方法本身，而不是简单的换个对象就行了

6.❤️接口和抽象类的区别
1.定义，关键词
2.抽象类是单继承，extends，接口可以实现的多个，implement
3.其中包含的内容，抽象类可以有变量，成员方法，接口中有final变量+abstract方法
4.使用的场合
抽象类：is a
接口： has a
5.相同点：都不能生成实例对象,都没有构造方法

❤️❤️❤️❤️❤️❤️决定使用抽象类 还是接口
is a   ---->abstract  防盗门是门    （一个类别=抽象）
has a  ---->接口       门用到锁       （一个部分=接口）


总结：在类，接口，抽象中选择
    is a                   （一个类别=抽象）
    has a (二选一)      （一个部分=接口）
                    （可更换的部分=类）
注：现在我的认识是：类一定比接口好，接口的功能全能用类来实现！当然这是错的！

  1. 先写接口 -> 抽象类 ->实现类 -> test测试
    接口 -> 实现类 -> test测试

  2. 接口的优势
    多继承
    设计和实现完全分离
    更自然使用多态
    更容易搭建程序框架
    更容易更换

  3. 算数异常

  4. has.nextInt();

  5. 五个关键字
    try 执行可能产生异常的代码
    catch 捕获异常
    finally 终会执行
    throw 抛出
    throws 声明

  6. java.lang.Exception

  7. e.printStacktTrace() 堆栈追踪功能
    这个注释掉，就没有异常信息输出了

  8. try catch的三种情况 ，以及执行情况
    没异常 try->继续
    有异常，捕获 try->catch->打印出catch中的异常->继续
    有异常，没捕获 try->中断->jvm打印出异常

    总结：catch 只有匹配了异常才能执行，当参数写Exception时，一定能匹配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

*****例子1；*******

try {
	Scanner scan = new Scanner(System.in);
	System.out.println("请输入第一个数");
	int input1 = scan.nextInt();
	System.out.println("请输入第二个数");
	int input2 = scan.nextInt();
	System.out.println(String.format("%d/%d=%d", input1,input2,input1/input2));
} catch (Exception e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	System.err.println("_____catch_____");
}
System.out.println("程序结束");
输出：
请输入第一个数
1
请输入第二个数
0
程序结束
java.lang.ArithmeticException: / by zero
    at package6.Exception1.main(Exception1.java:16)
_____catch_____
1
2
3
******例子2；*******
将   System.err.println("_____catch_____");  
 改为 System.out.println("_____catch_____");
输出：
请输入第一个数
1
请输入第二个数
0
_____catch_____
程序结束
java.lang.ArithmeticException: / by zero
    at package6.Exception1.main(Exception1.java:17
1
2
3
******例子3；*******
将    } catch (Exception e) {  
 改为  } catch (InputMismatchException e) {
输出：
    请输入第一个数
    1
    请输入第二个数
    0
    Exception in thread "main" java.lang.ArithmeticException: / by zero
        at package6.Exception1.main(Exception1.java:18)


    请输入第一个数
    q
    _____catch_____
    程序结束
    java.util.InputMismatchException
        at java.util.Scanner.throwFor(Scanner.java:864)
        at java.util.Scanner.next(Scanner.java:1485)
        at java.util.Scanner.nextInt(Scanner.java:2117)
        at java.util.Scanner.nextInt(Scanner.java:2076)
        at package6.Exception1.main(Exception1.java:15)

15.getMessage();输出一个异常的描述信息
自定义异常 system.err.print();

16.常见异常
arrayInexOutOfBounds 数组越界
NULLPointer 空指针异常
ClassNotFound 类没有定义
IllegalArgument 不合法参数
ClassCast 对象强制转换异常
NumberFormat abc->数字
NoSuchMethod
IO
SQL
17.error exception的不同
error
18.RuntimeException
19.finally
1.是否发生异常都执行
2.system.exit(1) 唯一可能不执行finally的情况

20 return 和 finally 的关系
try{

}catch(Exception e){
    syso（“*”);
    return 2;
}finall{
    syso();
}

当捕获到异常时，并且catch有返回return时，先执行finally，在执行return

21.
*
22.
按catch的顺序：先父类 后子类

23.main方法不能改
public static int main(String[] args) {

错误: main 方法必须返回类 package6.Exception1 中的空类型值, 请
将 main 方法定义为:

public static void main(String[] args)
24.throws用法

“嗨哥们，这个A方法容易出错，调用这个A方法的B方法必须进行处理”
处理方法：
    1.B()throws Exception{}
    2.B(){
        try{
            A();
        }catch(Exception e){
            e.
        }
    }

注：1方法输入让jvm处理异常，那么，可能会中断程序

25.throw 的用法

1
2
3
4
5
6
7
8
9
10
********例子1******
public void setAge(int age) throws Exception {//这里要声明throws
	
	if(age > 0 && age < 130){
		this.age = age;
	}
	else{
		throw new Exception("年龄必须大于0 小于130");
	}
}
输出：
Exception in thread "main" java.lang.Exception: 年龄必须大于0 小于130
at package7.Person.setAge(Person.java:16)
at package7.ExceptionTest.main(ExceptionTest.java:6)    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
********例子2******
public void setAge(int age) {
	
if(age > 0 && age < 130){
	this.age = age;
}
else{
	try {
		throw new Exception("年龄必须大于0 小于130");
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
输出：
java.lang.Exception: 年龄必须大于0 小于130
at package7.Person.setAge(Person.java:17)
at package7.ExceptionTest.main(ExceptionTest.java:6)
0

总结：
    写了throw之后，必须进行2选一的操作

26.log 日志的作用
1.用来记录系统运行中的而一些中亚操作信息
2.便于见识系统运行，帮助用户提前发现和避开可能出现的问题，或出现问题后根据日志找到原因
27.日志的分类
sql日志 记录增删该查
异常日志 记录异常
业务日志 记录业务操作
28.输出级别 8
OFF
Fatal
ERROR
warn
info
debug
trace
all
29.
配置日志格式
输出位置
文件名.log