JavaSe
public //在java中 所有的类都默认直接继承object类
Dos命令
JDK和jre
JDK是开发工具
jre是运行环境
JAVA运行机制
编译型
java源文件 通过java编译器编译 编译成class文件 让计算机能读懂
解释型
数据类型
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
弱类型语言
JAVA数据类型
基本数据类型
整数型
1字节等于8位
int 占4个字节范围 ：-2147483648~2147483647 最为常用 32位
byte 占1个字节范围：-128~127 8位
short 占2个字节范围：-32768~32767 16位
long 占8个字节范围：-9223372036854775808~9223372036854775807 64位
浮点型
float占4个字节
double 占8个字节
字符型
char占两个字节
布尔型
boolean 占1位其值只有true和false俩个
引用数据类型
类
接口
数组
类型转换
由于java是强类型语言，所以要进行有些运算的时候需要类型转换
低-------------------------------------------------------->高
short，byte，char-> int -> long -> float -> double
运算中，不同类型的数据先转化位同一类型，然后再进行运算
int i =128;
byte b = i; 会报错 需要类型转换
byte b = (byte)i;//输出结果位-128 内存溢出 加括号的为强制转换
强制转换 从高转到低
自动类型转换 低到高 都是自动转换
变量，常量，作用域
类变量
static修饰的
局部变量
public static void main(String[] args) {
//局部变量；必须声明 和初始化值
int i = 10;
System.out.println(i);
}
实例变量
//实例变量，从属于对象 在class类下面,如果不自行初始化，这个类型的默认值
//布尔值默认是false
//除了基本类型，其余的默认值都是null
String name;
int age;
类变量
public class Demo03 {
//类变量 static
static double salary = 2500;
//类变量 static
System.out.println(demo03.salary);
}
常量
final 代表常量
初始化后不能在改变值，不会变动的值
常量是一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
final 常量名=值；
final double pi = 3.14；
静态的常量 始终不会变的
public class Demo4 {
静态的常量 始终不会变的
//final可以在static前面 也可以在后面 修饰符不存在先后顺序
static final double pi = 3.14;
public static void main(String[] args) {
System.out.println(pi);
}
}
运算符
算术运算符 优先级（）
算术运算符：+, - , * , / , % , ++ , -- // % 取余数，模运算
赋值运算符：=
关系运算符：> , < , >=, <= , == , !=instanceof “==”相当于等于
逻辑运算符：&& ， || ，！
与&&（and:我和你两个都必须要） 或||（or：我或者你必须要俩个其中一个,只要有一个为true都为true） 非！（取反：）
位运算符：&，|，^，~，>>,<<,>>>(了解)
条件运算符：？：
扩展赋值运算符：+= ， -= ， *= ，/=
&和&&的区别都可以用作逻辑与的运算符，表示逻辑与（and），当两边的表达式都为真时才为真，只要有一方为false，则结果为false
&&具有短路功能如果第一个表达式为flsae，则不再计算第二个表达式
&可用作位运算符，当&操作两边表达式不是boolean类型的时候，&可用作为按位与操作
案例
//二元运算符 int a = 10; int b = 20; int c = 25; int d = 25; System.out.println(a+b); System.out.println(a-b); System.out.println(a*b); System.out.println(a/b); 这里 int a = 10; int b = 20; System.out.println(a/b);=0 因为是int类型的 结果0 由于是int类型的 结果是double 需要强转 System.out.println(a/(double)b); double 结果0.5
long a = 123123123123123L; int b = 123; short c = 10; byte d = 8; System.out.println(a+b+c+d); //Long 两个操作或者多个有一个为long 那么这个结果类型为long 如果没有long结果都为int System.out.println(b+c+d); //int System.out.println(c+d); //int
//关系运算符返回的结果：正确，错误 布尔值 int a = 10; int b = 20; int c = 21; // % 取余数，模运算 System.out.println(c%a); // c/a 21/10=2...1 21除10等2.1 又等于2余1 System.out.println(a>b); System.out.println(a<b); System.out.println(a==b); System.out.println(a!=b); 1 false true false true
++ 自增 -- 自减
++
++在前 先自增在赋值
++在后 先赋值在自增
--
以此类推
// ++ -- 自增 ，自减 一元运算符 int a = 3; //a++ 等于 a=a+1 int b = a++; //执行完代码后，先给b赋值，在自增 System.out.println(a); //++a 等于 a=a+1 int c = ++a; //执行完代码前，先自增，在给b赋值 System.out.println(a); System.out.println(b); System.out.println(c); //幂运算 2^3 2*2*2=8 double pow = Math.pow(3,2); System.out.println(pow);
逻辑运算符
&和&&的区别都可以用作逻辑与的运算符，表示逻辑与（and），当两边的表达式都为真时才为真，只要有一方为false，则结果为false
&&具有短路功能如果第一个表达式为flsae，则不再计算第二个表达式
&可用作位运算符，当&操作两边表达式不是boolean类型的时候，&可用作为按位与操作
//逻辑运算符
public class Demo5 {
public static void main(String[] args) {
//与&&（and:我和你两个都必须要） 或||（or：我或者你必须要俩个其中一个） 非！（取反：）
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true，如果一个为假不在运算
System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量有一个为真，结果才为true，两个都为假才为假，否则就是真
System.out.println("!(a && b):"+!(a&&b));//如果是真则为假，如果是假则为真
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);
System.out.println(c);
二进制算法
/* A = 0011 1100 上 B = 0000 1101 下 ------------------ A&（与）B = 0000 1100 A&B上下比较 如果上面两个都是1结果为1 一个1为0，两个0为0 A|（或）B = 0011 1101 A|B都是0为0，如果有一个1就为1 A^（异或运算）B = 0011 0001 A^B 上下位置相同为0 不相同为1(上下相同为0，不相同为1) ~B（非/取反）= 1111 0010 2*8 = 16 2*2*2*2 （左移:相当于乘2）<< >>（右移相当于除2） 箭头指向那边成为（左右移） 位运算效率极高！！ 0000 0000 0 0000 0001 1 0000 0010 2 0000 0011 3 0000 0100 4 0000 1000 8 0001 0000 16 */ System.out.println(2<<3);
字符串拼接
int a = 10;
int b = 20;
a+=b; //a = a+b
a-=b;
System.out.println(a);
//字符串连接符 +
System.out.println(a+b);
System.out.println(""+a+b);
//结果为1020 “+”运算符两侧 有String类型的 都会转换为String类型的
System.out.println(a+b+"");
//如果Sring类型的在后面就进行运算
三元运算
// x ? y : z //如果x==true ，则结果为y，否则结果为z int score = 50; String type = score<60 ? "不及格":"及格"; System.out.println(type);
Doc
package com.zhang.base;
/**
* @author zhangyitian
* @version 1.0
* @since 1.8
*/
public class Doc {
//类变量 在类定义的变量 属性
String name;
//方法
//author 作者名
//version 版本号
//since 指明需要最早使用的jkd版本
//param参数名
//return返回值情况
//throws异常抛出情况
/**
* @author zyt
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
//javadoc 参数 文件
//javadoc -encoding UTF-8 -charset UTF-8 Doc.java
//作业：学会查找使用idea生产javaDoc文档
Scanner 键盘录入
new();
1.一定要读取到有效字符后在可以结束输入
2.对输入有效字符之前遇到的空白，next（）方法会自动将其去掉
3.只有输入有效字符集后才将其后面输入的空白作为分隔符或者结束符
4.next（）不能得到带有空格的字符集
public static void main(String[] args) {
//创建一个扫描器对象 用于接收键盘数据 system.in输入
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收:");
//判断用户有没有输入字符串
//hasNext 下一个
if(scanner.hasNext()==true){
//使用next方式接收
String str = scanner.next();
System.out.println("输入的内容为："+str);
}
//凡是属于IO流的类，如果不关闭会一直占用资源，要养成好习惯用完就关闭掉
scanner.close();
}
nextLine()
1.以Enter为结束符，也就是说nextLine（）方法返回的是输入回车之前的所有字符
2.可以获得空白
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收:");
//判断是否还有输入 hasnextline
if (scanner.hasNextLine()==true){
String str = scanner.nextLine();//程序等待用户输入
System.out.println("输入的结果为："+str);
}
scanner.close();
}
不用if
public static void main(String[] args) {
//从键盘录入
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
//等待用户输入 敲下Enter
String str = scanner.nextLine();
System.out.println("输出的结果为："+str);
//关闭流
scanner.close();
}
案例
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//从键盘接受收据
int i = 0;
float f = 0.0f;
System.out.println("请输入整数：");
//如果那么
//判断输入的是否含有整数
if (scanner.hasNextInt()){
i = scanner.nextInt();//用于接收，是否有整数
System.out.println("整数数据："+i);
}else {
System.out.println("输入的不是整数数据");
}
System.out.println("请输入小数：");
//如果那么
if (scanner.hasNextFloat()){
f = scanner.nextFloat();//用于接收
System.out.println("小数："+f);
}else {
System.out.println("输入的不是小数数据");
}
scanner.close();
}
案例while
public static void main(String[] args) {
//我们可以输入多个数字，并求其总和与平均数，没输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：
Scanner scanner = new Scanner(System.in);
//定义一个总和
double sum = 0;
//计算输入了多少个数字
int m = 0;
System.out.println("请输入:");
//while 不停的去走 直到结束，
//通过循环判断是否还有输入，并在里面对每一次进行求和统计
//hasNextDouble是否还有下一个double的数
while (scanner.hasNextDouble()){
//如果有保存到一个变量x里double x= scanner.nextDouble();
double x = scanner.nextDouble();
//从double x = scanner.nextDouble();输入一个数
//m = m + 1;m++ 来统计输入了多少个数 每输入一个自己+1
m = m + 1;//m++
sum = sum + x;
System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
//因为sum在循环外面 所以不会每次变成0 循环的意思就是不停的在循环里面转知道输入的条件不满足 scanner。hasnextDouble才跳出循环
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值是" + (sum / m));
scanner.close();
}
顺序结构
1.JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
2.顺序结构是最简单的算法结构
3.语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干各一次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构
选择结构
if单选择结构
很多事换需要去判断一个的东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
语法：
if（布尔表达式）{
0000//如果布尔表达式为true将执行的语句
}
如果if成功等于true，不写则默认等于true，
如果等于true将执行0000的语句
如果true 执行下面的语句 false直接 跳过这个语句往下面走
equals:判断字符串是否相等
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容：");
//接收 保存到s
String s = scanner.nextLine();
//equals:判断字符串是否相等
//s.equals("Hello"判断s是否等于hello
if (s.equals("Hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
scanner输入Hello结果为 s end
输出除了Hello以外的字符 结果都为End
if双选择结构
我们需要两个判断，需要一个双选择结构，所以有了if-else结构
语法
if（布尔表达式）{
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
如果是正确的就走语句1 错误的走语句2
public static void main(String[] args) {
//考试分数大于60就是及格，小于60不及格
Scanner scanner = new Scanner(System.in);
int grade = 0;
System.out.println("请输入分数:");
//int i = scanner.nextInt();等待用户输入
int score = scanner.nextInt();
if (score>=60){
System.out.println("成绩合格");
}else {
System.out.println("成绩不合格");
}
scanner.close();
}
if多选择结构
语法
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码语句1
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码语句2
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码语句3
}else {
//如果以上布尔表达式都不为true执行代码
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
/*
if 语句至少有1个 else语句，else 语句在所有的 else if语句之后。
if 语句可有若干个 else if语句，他们必须在else 语句之前
一旦其中一个else if 语句检测 true，其他的else if 以及else 语句都将跳过执行
*/
int score = scanner.nextInt();
if (score==100){
System.out.println("恭喜满分");
}else if (score<100 && score>=90){
System.out.println("A级");
}else if (score<90 && score>=80){
System.out.println("B级");
}else if (score<80 && score>=70){
System.out.println("C级");
}else if (score<70 && score>=60){
System.out.println("D级");
}else if (score<60 && score>=0){
System.out.println("不及格");
}else { ////else必须在所有的else if语句之后
System.out.println("输入的成绩不合法");
}
scanner.close();
}
嵌套的if结构
使用嵌套的if 。。。else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或者esle if语句。你可以像if语句一样嵌套else if。。。else。
语法
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}
}
switch多选择结构
1.多选择结构还有一个实现方式就是switch case 语句。
2.switch case 语句判断一个变量与一系列值中某个值是否相等，每一个值称为一个分支
3.switch 语句中的变量类型可以是：
byte ，short ，int 或者 char
从 java se 7开始
switch 支持字符串String 类型了
同时 case标签必须为字符串常量或字面量
语法
表达式
switch(expression){ 去判断一个东西
case value: 假设等于1 走你的语句
//语句
break；//可选
case value： 如果等于2 等于你的语句
//语句
break；//可选
//你可以有任意数量的case
default：//可选 条件都不满足就走default
//语句
}
//case 穿透 判断是否继续输出 //匹配一个值 匹配成功返回当前case的值
switch匹配一个具体的值
案例
public static void main(String[] args) {
//JDK7的新特性，表达式结果可以是字符串！！！
//字符的本质还是数字
//反编译 java---class（字节码文件）---反编译（IDEA）
String name = "艺";
switch (name){
case "张":
System.out.println("张益田");
break;
case "艺":
System.out.println("李小龙");
break;
default:
System.out.println("你在干什么");
}
}
SwitchScanner
输入月份判断季节
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
switch(s){
case "1":
case "2":
case "3":
System.out.println("春");
break;
case "4":
case "5":
case "6":
System.out.println("夏");
break;
case "7":
case "8":
case "9":
System.out.println("秋");
break;
case "10":
case "11":
case "12":
System.out.println("冬");
break;
default:
System.out.println("输入有误！！");
break;
}
}
输入季节判断月份
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入季节:");
String s = scanner.next();
switch (s){
case "春":
System.out.println("1月,2月,3月");
break;
case "夏":
System.out.println("4月,5月,6月");
break;
case "秋":
System.out.println("7月,8月,9月");
break;
case "冬":
System.out.println("10月,11月,12月");
break;
}
scanner.close();
}
循环结构
while循环
while是最基本的循环，它的结构为:
while（布尔表达式）{
//循环内容
}
1.只要布尔表达式为true，循环就会一直执行下去。
2.我们大多数情况会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
3.少部分情况需要循环一直执行，比如服务器的请求响应监听等。
4.循环条件一直为true就会造成无限循环（死循环），我们正常业务变成中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃！！！
思考1+2+3+...+100=?
while和do...While的区别：
while先判断后执行。do...while是限制性后判断！
Do...while总是保证循环体会被至少执行一次！这是他们的主要差别。
while和do...while的区别
public static void main(String[] args) {
int i = 0;
while (i<0){
System.out.println(i);
i++;
}
System.out.println("==========");
do {
System.out.println(i);
i++;
}while (i<0);
//输出结果====================
0
while不满足条件就不再运行
do...while保证代码执行一次
}
do...while循环
对于while 语句而言，如果不满足条件，则不能进入循环。但有时我们需要即使不满足条件时，也至少满足一次。
do...while 循环和while 循环相似，不同的是，do...while循环至少会被执行一次
do{
//代码语句
}while(布尔表达式)；
public static void main(String[] args) {
int i = 0;
int sum = 0;
//do...while 先执行后判断
do {
sum = sum + i;
i++;
}while (i<=100);
System.out.println(sum);
}
For循环
虽然所有循环结构都可以用while或者do...while表示，但java提供了另一种语句-for循环，使一些循环结构变得更加简单。
for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。
for循环执行的次数是在执行前就确定的。语法格式如下：
for（初始值；布尔表达式；更新）{
//代码语句
}
关于for循环的以下几点说明：
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
再次检测布尔表达式。循环执行上面的过程。
j * i = j*i
i *i =1
99乘法表
public static void main(String[] args) {
/*
1.我们先打印第一列
2.我们把固定的1再用一个循环包起来
3.去重复项
4.调整样式
*/
for (int i = 1; i<= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
案例2
public static void main(String[] args) {
//练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
for (int i = 0; i <= 1000; i++) {
if (i%5==0){ //如果除5等于0那他就是1-1000被5整除的数把他输出
System.out.print(i+"\t");
}
if (i%(5*3)==0){ //每输出三个换行
System.out.println();
}
}
//System.out.print(i+"\t");"\t"同行加空格
//println 输出完会换行
//print 输出完不会换行
}
案例三
public static void main(String[] args) {
//练习1：计算0到100之间的奇数和偶数的和
int oddSum = 0;//保存奇数的和
int evensum = 0;//保存偶数的和
//执行流程：如果i=0，满足i<100条件成立 走if循环体，走完后 走i++，
// 走完后再走i<100,还成立继续走，直到不满足i<100
for (int i = 0; i < 100; i++) {
//i%2!=0 如果i除2不等于0就说明它有余数 有余数就说明是奇数
if (i%2!=0){//奇数
oddSum+=i;
}else { //取反偶数
evensum+=i;
}
}
System.out.println("奇数的和："+oddSum);
System.out.println("偶数的和："+evensum);
}
增强for循环
java5引入了一种主要用于数组或集合的增强型for循环
java增强for循环语法格式如下
for（声明语句：表达式）
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者返回值为数组的方法
重点：循环数组和集合的
public static void main(String[] args) {
int [] numbers = {10,20,30,40,50}; //定义一个数组
for (int i = 0;i<5;i++){
System.out.println(numbers[i]);
}
System.out.println("==============");
//遍历数组的元素
for (int x:numbers){
System.out.println(x);
}
}
break continue
break在循环语句的主体部分，均可用在break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
if (i==30){
break;
}
输出结果1-30
}
}
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
if (i%10==0){
System.out.println();
continue;
}
System.out.print(i);
}
}
案例
打印三角形
public static void main(String[] args) {
//打印三角形 5行
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >=i; j--) {
System.out.print(" ");
}
for (int j = 1; j <=i ; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
Java方法详解
方法的定义
1.java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下定义一个方法包含以下语法：
2.方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
1.修饰符：这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
2.返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需要的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
3.方法名：是方法的实际名称，方法名和参数表共同构成方法签名。
4.参数类型：参数像一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包括任何参数。
形式参数：在方法被调用时用于接收外界输入的数据，定义作用。
实参：调用方法时实际传给方法的数据。
方法体：方法体包含具体的语句，定义该方法的功能
public static（ 修饰符） int（返回值类型） add(int a,int b){
修饰符 返回值类型 方法名（参数类型 参数名）{
。。。
方法体
。。。
return 返回值；
}
如果方法存在返回值类型的情况下，一定要通过return这个关键字返回出去，如果是void就不用return。 retur写到最下面
方法调用
1.调用方法：对象名.方法名(实参列表) 2.类名.方法
2.java支持两种调用方法的方式，根据方法是否返回值来选择
3.当方法返回一个值的时候，方法调用通常被当做一个值。例如
int larger = max(30,40);
如果方法返回值是void，方法调用一定是一条语句。
system.out.println("Hello,kuangshen!")
扩展
main方法是被java虚拟机调用的，java中只有值传递
方法的重载
重载就是在一个类中，有相同函数名称，但形参不同的函数。
public static void main(String[] args) {
int max = max(10, 20);
System.out.println(max);
} 方法名称必须相同
public static int max(int num1,int num2){
int result = 0;
if (num1==num2){
System.out.println("a==b");
return 0; //终止方法
}
if (num1>num2){
result = num1;
}else {
result = num2;
}
return result;
} 方法名称必须相同
public static double max(double num1,double num2){
double result = 0;
if (num1==num2){
System.out.println("a==b");
return 0; //终止方法
}
if (num1>num2){
result = num1;
}else {
result = num2;
}
return result;
}
方法的重载规则：
1-2为必须满足的条件
**1.方法名称必须相同。**
**2.参数列表必须不同（个数不同，或类型不同，参数列表顺序不同等）**
3.方法的返回类型可以相同也可以不相同。
4.仅仅返回类型不同不足以成为方法的重载
public static void main(String[] args) {
double add = add(20, 30);
System.out.println(add);
}
public static int add(int num1,int num2){
return num1+num2;
}
public static double add(double num1,double num2){
return num1+num2;
}
命令行传参
有时候你希望运行一个程序时候在传递给它消息。
这要靠传递命令行参数给main（）函数实现。
可变参数
1.JDK1.5开始，java支持传递同类型的可变参数给一个方法。
2.在方法声明中，在指定参数类型后加个省略号（...）
2.一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
案例
public static void main(String[] args) {
Demo4 demo4 = new Demo4();
demo4.test(1,2,3,4,5,6);
}
//传一个int类型的i,不知道要传递多少个在int后面加省略号
public void test(int... i){
System.out.println(i[1]);
总结：可变参数必须要放在最后面。
必须是同一类型的
当demo4.test（）；没有传入值输出i[0]会报错 数组下标越界
}
递归
A方法调用B方法，我们很容易理解！
递归就是：A方法调用A方法，即自己调用自己
利用递归可以用简单的程序来解决一些复杂问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体：什么时候需要调用自身方法
/*
阶乘
1！ 1
2！ 2*1
3！ 3*2*1
4！ 4*3*2*1
5！ 5*4*3*2*1
*/
//递归思想
public static void main(String[] args) {
System.out.println(f(3));
}
//2 2 * f(1)
//3 3 * f(2)
public static int f(int n ){
if (n==1){
return 1;
}else {
return n*f(n-1);
}
}
数组
1.数组的概念
数组是相同数据类型的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而来
其中，每一个数据称作一个数组元素，每个数组元素可通过下标来访问他们
()
数组声明创建
首先必须声明数组变量，才能在程序中使用。下面是声明数组变量的语法
dateType[ ] arrayRefVar; // 首选的方法
dateType arrayRefVar [ ]; //效果相同，但不是首选方法
public static void main(String[] args) {
//变量的类型 [ ] 变量名 = 变量的值；
//数组类型
//这是个int类型的数组 数组名为nums 没有值是定义
int[] nums; java中用这个
int nums2[]; 这是c C++语言常用的 这个了解即可
}
java语言使用new操作符来创建数组，语法如下：
dateType[ ] arrayRefVer = new dateType[arraySizr];
数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度 arrays.length
public static void main(String[] args) {
//变量的类型 变量名 = 变量的值；
//数组类型
//这是个int类型的数组 数组名为nums 没有值是定义
int[] nums; //1.声明一个数组
nums = new int[10];//2.创建一个数组
1和2 总结就是 声明和创建总结一起
int[] nums = new int[10]
//3.给数组元素中赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
//计算所有元素的和
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("总和为："+sum);
}
内存分析
1.声明数组的时候只会出现在栈中
2.只有new出来 创建了 才会在堆中出现
3.给数组赋值了 中这10个值才会出现对应的值
三种初始化状态
静态初始化
int [ ] a = {1,2,3};
Man [ ] mans = {new Man(1,1),new Man(2，2)}；
动态初始化
int [ ] a = new int[2];
a[0]=1;
a[1]=2;
public static void main(String[] args) {
//静态初始化: 创建+赋值
int[] a = {1,2,3,4,5,6,7,8};
System.out.println(a[0]);
//动态初始化 手动去赋值 包含默认初始化 没有赋值都是0
int[] b = new int[10];
b[0]=10;
b[1]=10;
System.out.println(b[0]);
System.out.println(b[1]);
System.out.println(b[2]);
输出结果1 10 10 0
}
数组的默认初始化
数组是引用数据类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
数组的四个基本特点
1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素必须是相同类型，不能出现混合类型
3.数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
4.数组变量属于引用数据类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的
数组边界
下标的合法区间：[0,length-1],如果越界就会报错；
public static void main（String [ ] args）{
int[ ] a= new int [2];
System.out.println(a[2]);
}
ArrayIndexOutOfBoundsException：数组下标越界异常！
小结：
数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度是确实的 ，不可变的。如果越界会报下标越界
public static void main(String[] args) {
//静态初始化: 创建+赋值
int[] a = {1,2,3,4,5,6,7,8};
System.out.println(a[0]);
for (int i = 0; i < a.length ; i++) {
System.out.println(a[i]);
}
用for循环遍历出数组的所有的值
案例
public class ArrayDemo3 {
public static void main(String[] args) {
int [] a= {1,2,3,4,5};
//打印全部的数组元素
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
System.out.println("===========");
int sum = 0;
for (int i = 1; i < a.length; i++) {
sum = sum + a[i];
}
System.out.println("sum的总和为："+sum);
System.out.println("===========");
//查找最大元素
//定义一个最大的数 max a[0]初始化的时候等于数组第一个数
int max = a[0];
for (int i = 0; i < a.length; i++) {
if (a[i]>max){
max = a[i];
}
}
System.out.println("数组的最大值为"+max);
}
数组的使用
For-Each 循环
public static void main(String[] args) {
int [] arrays = {1,2,3,4,5,6};
//JDk1.5 没有下标 定义数组 用增强型for循环
for (int array : arrays) {
System.out.println(array);
} 类型
for( int a : 数组名
)
}
数组作方法入参
public static void main(String[] args) {
int [] arrays = {1,2,3,4,5,6};
printArray(arrays);
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
数组作返回值
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组
int a[ ] [ ] = new int [2] [5]
以上二维数组a 可以看成一个两行五列的数组
数组拓展
Arrays类
冒泡排序
package com.lx;
public class maopaopaixu {
public static void main(String[] args) {
int [] arr = {1, 5, 2, 7 ,6, 8};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length-1 ; j++) {
if (arr[j] < arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for (int a = 0; a < arr.length ; a++) {
System.out.print(arr[a]+" ");
}
}
}
面向对象编程（oop）
java的核心思想就是oop oo面向对象
属性加方法变成一个类
面向对象&面向过程
面向过程思想（线性思维）
步骤清晰简单，第一步做什么，第二步做什么。。。
面向过程适合处理一些较为简单的问题
面向对象思想/
物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
什么是面向对象
面向对象变成（Object-Oriented Programming，OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
从认识论角度考虑是先有对象后有类。对象，是具体的事物，类是抽象的，是对对象的抽象
从代码运行角度是先有类后有对象。类是对象的模板
什么是面向对象
以类的方式组织代码，以对象的方法（封装）数据
三大特征：
封装 （数据的隐藏）大多数是对于属性来的 对于方法里面 用的比较少 private 属性私有
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
该露的露，该藏的藏
我们程序设计要求“高内聚，低耦合” 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
重点需要记住： 属性私有，get/set
get: 获取属性 set ： 设置属性
注意： set方法里面可以做一些安全性的判断
/* 封装的意义
1.提高程序的安全性，保护程序
2.隐藏代码的实现细节
3.统一接口
4.提高了系统的可维护性
*/
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("张艺田");
//方法是相同的，方法名一定相同
//参数列表
System.out.println(s1.getName());
s1.setAge(99);
System.out.println(s1.getAge());
}
//属性:字段
//private 属性私有
private String name;//姓名
private int id;//学号
private char sex; //性别
private int age;
//私有的属性 要提供一些可以操作这个属性的方法
//提供一些public的get set的方法
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120 || age<0){ //不合法的
this.age = 0;
System.out.println("请输入合法的年龄");
}else {
this.age = age;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
继承 私有的private修饰的属性是无法继承的
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思就是“扩展”。 子类是父类的扩展
java中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系
object类
super-----》this
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法！
this：
代表的对象不同：
this：本身调用本身这个对象
super：父类对象的引用
前提：
this没有继承也可以使用
super：只有继承条件才可以使用
构造方法：
this();本类的构造
super();父类的构造
父类
package com.oop.demo4;
//person 人 是父类 基类
//在java中 所有的类都默认直接继承object类
public class Person {
public void say(){
System.out.println("说了一句话");
}
//public公共的
//private私有的
//default默认的
//protected受保护的
private int money = 10_0000_0000;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
子类
package com.oop.demo4;
//学生 is 人 派生类 子类
//子类继承了父类，就会拥有父类的全部方法，
public class Student extends Person{
}
测试类调用子类
package com.oop.demo4;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
student.getMoney();
System.out.println(student.getMoney());
//输出结果 说了一句话
// 1000000000
}
方法重写
重写：
前提：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大，不能缩小 public>protected>default>private
4.重写可能会抛出异常 ： 可以被缩小不能扩大
重写，子类的方法和父类必要一致：方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不满足！
alt+insert override
子类
package com.oop.demo4;
public class B extendsA{
@Override//重写
public void test() {
System.out.println("A---t1est");
}
}
父类
package com.oop.demo4;
//父
public class A {
public void test(){
System.out.println("B--test");
}
}
测试类
package com.oop;
import com.oop.demo4.A;
import com.oop.demo4.B;
//重写都是方法的重写和属性无关
//静态的方法和非静态的方法区别很大！
//第一个条件 非静态 重写
public class ApplicationAB {
public static void main(String[] args) {
B b = new B();
a.test(); //B
//父类的引用指向子类
A a = new A();//B重写了A的方法，子类重写了父类的方法
b.test();//A //重写方法只给非静态方法有关
}
}
如果父子类里面都有同一个方法，只要子类没有重写父类，那么他就调用父类的，如果子类重写了父类就调用子类的
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
有继承关系
子类重写父类的方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态
instanceof 类型转换 引用类型之间的
多态：
注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
father f1 = new Son(); 父类指向子类
不能被重写的方法
1.static方法 属于跟类相关的它是 它不属于实例
2.final 常量
3.private 方法 私有的
父类
package com.oop.demo5;
public class person {
public void run(){
System.out.println("run");
}
public void fu(){
System.out.println("fu");
}
}
子类
package com.oop.demo5;
public class student extends person{
@Override
public void run() {
System.out.println("儿子");
}
public void eat(){
System.out.println("eat");
}
}
测试类
package com.oop;
import com.oop.demo5.person;
import com.oop.demo5.student;
public class Applicationduotao {
public static void main(String[] args) {
//一个对象的实例类型是确定的
//new student();
//new person();
//可以指向的引用类型就不确定了 //父类的引用指向子类
student s1 = new student();//student子类指向
person s2 = new student();//person父类指向
Object s3 = new student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
s1.run();
s2.run(); //子类重写了父类的方法，执行子类的方法
//student子类指向 子类有这个方法
//student 能调用的方法都是自己的或者父类的
s1.eat();
//父类型 可以指向子类，但是不能调用子类独有的方法
// person s2
回顾方法及加深
方法的定义
修饰符 返回值类型 方法名（参数类型（int），参数名（a））{
方法体
return 返回值;
}
修饰符
返回值类型
break：跳出switch，结束循环和return的区别
方法名 ：注意规范，见名知意
参数列表 ：（参数类型，参数名） 一个方法可以有多个参数
异常抛出
方法的调用： 递归
静态方法：加static
非静态方法 ：不加 static
package com.oop.demo1;
public class Demo2 {
public static void main(String[] args) {
Student.say(); 类调用类 用类名点该类的方法
该类必须是被static修饰的才能直接类名点方法名
}
}
package com.oop.demo1;
//学生类
public class Student {
//方法
public static void say(){
System.out.println("学生说话了");
}
}
另一种方法 实例化这个类 new
非静态方法
public static void main(String[] args) {
// 实例化这个类 new
//对象类型 对象名 = 对象值；
Student student = new Student();
student.say();
}
//static和类一起加载的 静态方法只能调用静态方法，非静态的也可以调用静态的方法和属性
public static void a(){
// b();
}
//类实例化之后才存在 实例化就是new
public void b(){
a();
}
形参和实参
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
int add = add(30, 20);
System.out.println(add);
}
public static int add(int a,int b){
return a+b;
} 加static的方法
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
Demo3 demo3 = new Demo3();
int add = demo3.add(10, 2);
System.out.println(add);
}
public int add(int a,int b){
return a+b;
} 不加static需要实例化 new 类名
值传递和引用传递
//值传递
public static void main(String[] args) {
int a = 1;
System.out.println(a);
change(a);
System.out.println(a);
}
//返回值为空
public static void change(int a){
a = 10;
}输出结果都为1
public class Demo5 {
//引用传递：一般传递一个对象 本质还是值传递
public static void main(String[] args) {
person person = new person();//实例化过程
System.out.println(person.name);
Demo5.change(person);
System.out.println(person.name);
}
public static void change(person person){
//person是一个对象：指向的是----》person person = new person();//实例化过程
person.name="秦将";
}
}
//定义一个person类，有一个属性为 name
class person{
String name;
}
this关键字
类与对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
动物，植物，手机，电脑....
person类，pet类，Car类等，这些类都是用来描述/定义某一些具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
张三就是人的一个具体实例，张三接力的旺财是狗的一个具体实例。
能够体现出特点，具体展现出功能的是具体的实例，而不是一个抽象的概念
package com.oop.demo2;
//当前的测试类
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//Student学生类
//类：抽象的类需要实例化
//类实例化后会返回一个自己的对象 ！
//student对象就是一个Student类的具体实例
Student xiaoming = new Student(); //把抽象的学生类student 实例化出来变成一个对象
Student xiaohu = new Student();
xiaoming.name="小明";
xiaoming.age=18;
xiaohu.name="小虎";
xiaohu.age=11;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
System.out.println(xiaohu.name);
System.out.println(xiaohu.age);
}
}
类调用类
package com.oop.demo2;
//学生类
public class Student {
//一个类里面只有属性和方法
//属性：字段
String name;//null
int age; //0
//方法
//this代表当前这个类 this.name代表当前这个名字
public void study(){
System.out.println(this.name);
}
}
创建与初始化对象
使用new关键字创建对象
使用new关键字的时候，除了分配内存空间之外，还会给创建好的对象 进行默认的初始化 以及对类中构造器的调用
构造器
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
1.必须和类的名字相同
2.必须没有返回值类型，也不能写void
构造器要必须掌握
构造器案例
package com.oop.demo2;
//测试类
public class ApplictionPerson {
public static void main(String[] args) {
//new 实例化的一个对象
person person = new person("张艺田",22);
System.out.println(person.name);
System.out.println(person.age+"岁");
}
package com.oop.demo2;
public class person {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
int age;
//就是无参构造 构造器的第一个作用就是实例化初始值
//1.使用new关键字，必须要有构造器，本质是在调用构造器
//2.用来初始化值
public person(){
}
public person(String name, int age) {
this.name = name;
this.age = age;
}
//有参构造 一旦定义了有参构造，无参就必须显示定义
public person(String name){
this.name = name;
}
//alt+insert 创建构造器
//Constructor 有参构造
//Select None 无参构造
/*
特点：
1.构造器和类名相同
2.没有返回值
作用：
1.new 本质在调用构造方法
2.初始化对象的值
注意点：1.定义有参构造后，如果想使用无参构造，显示的定义一个无参的构造
*/
}
内存分析
第一步加载堆方法区加载Appliction类，这个类有main()方法 常量池（字符串）大黄
然后第一个事情 执行main方法 它在栈的最下面第一步 new了 Pet加载Pet类，进入pet类。然后堆方法区出现了 Pet类 他有自己的属性 name age shout（）方法 当前的字段都是初始化默认值
null 0 然后通过new pet（）这模板生成一个具体的的对象dog
然后栈区生成了dog变量（它只是一个变量名字，引用变量名）
通过new Pet（）：0x0001 默认的name age 大黄 12 有dog.shout（）方法这个方法是调用了 Pet类中的shout方法
在Applicction类中又new了个new pet（） 命名cat这时栈中又出现了cat 然后栈区生成了cat变量（它只是一个变量名字，引用变量名）给它cat赋值
通过new Pet（）：0x0001 默认的name age mimi 11
静态方法区static 是一开始就加载的 和类一起加载的 所有的对象都可以用到它
总可以分为两部分 左边是栈 右边是堆 堆里有个方法区
堆里一般存放创建的对象 栈里面都是方法 和引用
Application类
package com.oop.demo2;
public class ApplictionPet {
public static void main(String[] args) {
Pet dog = new Pet(); //new了Pet这个类 调用了无参构造
dog.name="大黄";
dog.age=12;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
Pet cat = new Pet();
cat.name="mimi";
cat.age=11;
System.out.println(cat.name);
System.out.println(cat.age);
}
Pet类
package com.oop.demo2;
public class Pet {
String name;
int age;
public void shout(){
System.out.println("叫了一声" );
}
}
简单小结类与对象
/*
1.类与对象
类是一个模板：类是抽象的，对象是一个具体的实例
2.方法
定义，调用
3.对象的引用
引用类型：基本类型（8）
对象是通过引用操作的：栈---》堆（地址）
4.属性：字段 field 成员变量
默认初始化：
数字：0 0.0
char ： u0000
boolean ：false
引用：通通为null
修饰符 属性类型 属性名 = 属性值！
5.对象的创建与使用
必须使用new 关键字创造对象，构造器 new person
Person kuangshen = new person（）；
对象的属性 kuangshen.name
对象的方法 kuangshen.sleep()
6.类 类里面只有属性和方法
静态的属性 属性
动态的行为 方法
*/
}
static关键字详解
package com.oop.demo6;
//static : 加在方法上就是静态方法 加在属性上就是静态属性
public class Student {
private static int age; //静态的变量
private double score; //非静态变量
public void run(){
go();//非静态方法可以调用静态方法
}
public static void go(){
}
public static void main(String[] args) {
// Student s1 = new Student();
//
// System.out.println(Student.age);//类变量
// System.out.println();//score 不是静态变量无发被类调用
// System.out.println(s1.age);
// System.out.println(s1.score);
//没有被static修饰的方法run（）
new Student().run();
Student student = new Student();
student.run();
//被static修饰的方法可直接用类名直接调用
Student.go();
//也可以不用类名点
go();
}
抽象类
package com.oop.demo7;
//abstract 抽象类 单继承
public abstract class Action {
//约束~有人帮我们实现
//abstract,抽象方法 只有名字，没有方法的实现
public abstract void deSomething();
//1.不能new这个抽象类，只能靠子类去实现它；约束！
//2.抽象类里面可以写普通方法
//3.抽象方法必须在抽象类中
//抽象的抽象：约束~
//存在的意义 抽象出来的 提高开发效率
package com.oop.demo7;
//抽象类的所有方法，继承了他的子类都必须要实现他的方法
public class a extends Action{
@Override
public void deSomething() {
}
}
接口
普通类 ：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！ 自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程
interface
接口作用：
1.约束
2.定义一些方法，让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例化 接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法 实现了接口的类，就需要重写接口中的方法
内部类
内部类就是一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就是内部类，类对于B类来说就是外部类
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类
异常 Exception
简单分类
检查性异常：最具代表的检查性异常时用户错误或问题引起的异常，这是程序员无法预见的。 例如打开一个不存在的文件时，异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常：运行时异常时可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误: 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略，例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到
异常体系结构
java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception
Exception
在Exception分支有一个重要的子类 RuntimeException（运行时异常）
ArrayIndexOutOfBoundsException （数组下标越界）
NullPointerException （空指针异常）
ArithmeticException （算术异常）
MissingResourceException （丢失资源）
ClassNotFoundException （找不到类）
等异常，这些异常是不检查异常程序中可选择捕获处理，也可以不处理
异常处理机制
抛出异常
捕获异常
异常处理五个关键字
try（尝试着去处理什么东西，监控区域），
catch（捕获异常），
finally（无论执不执行最后都会走），
throw（），用于抛出异常，从方法中抛出异常
throws（）从方法中抛出异常
自定义异常
浙公网安备 33010602011771号