初学Java（4）

最新推荐文章于 2022-08-04 20:31:16 发布

qq_43308791

最新推荐文章于 2022-08-04 20:31:16 发布

阅读量200

点赞数

分类专栏： JAVA 初

本文链接：https://blog.csdn.net/qq_43308791/article/details/84928917

版权

JAVA 初专栏收录该内容

2 篇文章 0 订阅

订阅专栏

六、面向对象
15.Object 是类层次结构的根类，每个类都使Object作为超类，所有对象（包括数组）都实现这个类的方法

是所有对象的直接或间接父类，传说中的父类
该类中定义的肯定是所有对象都具备的功能
在object类中主要包括clone(),finalize(),equals(),toString()等方法，其中常用的两个方法为
equals()和toStrong() 方法，由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法
重要方法：
1.getClass()方法
是Object类定义的方法，他会返回对象执行时的Class实例，然后使用此实例调用getNamw()方法可以取得类的名称
格式：getClass().getName();
2.toString()方法
是将一个对象返回为字符串形式，会返回一个String的实例，在实际的应用中通常重写toString()方，为对象提供一个特定的输出的模式，
当这个类转化为字符串连接时，将自动调用重写的toString()方法
3.equals()方法
比较“”运算符与equals()方法，“”运算符比较的是两个对象的引用是否相等，而equals()方法比较的是两个对象的实际内容
*在自定义的类中使用equals()方法进行比较是，将返回false,因为equals()方法的默认实现是使用“==”运算符比较两个对象的引用地址
*而不是比较对象的内容，所以要想真正做到比较两个对象的内容，需要在自定义类中重写equals()方法

*class Demo
*{ //暗含

Demo{super();}
}

*class ObjectDemo
*{
*public static void main(String[] args)
*{ Demo d1 = new Demo();

Demo d2 = new Demo();
Demo d3 = d1;
System.out.println(d1.equals(d2)); //结果：false
System.out.println(d1.equals(d3)); //结果：true
System.out.println(d1==d2); //false
System.out.println(d1==d3); //true
Person p1 = new Person();
Person p2 = new Person();
System.out.println(“person:”+p1.equals(p2)); //运行结果：person：false

object类中已经提供了对对象是否相同的比较方法
如果自定义中也有比较相同的功能，没有必要重新定义
只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖

16.在java语言中提供了一个执行数学基本运算的Math类，该类包括常用的数学运算方法，

如三角函数方法、指数函数方法、对数函数方法、平方根函数方法等一些常用数学函数
1.Math类
主要包括三角函数方法、指数函数方法、取整函数方法、取最大值、取最小值以及平均值函数方法，
这些函数被定义为main形式，所以在程序中应用比较简便
形式：Math.数学方法
数学常量：Math.PI Math.E
2.常用的数学方法
1）三角函数方法
Math类中包含：
public static double sin(double a); 返回角的三角正弦
public static double asin(double a); 返回一个值的反正弦
public static double acos(double a); 返回一个值的反余弦
public static double atan(double a); 返回一个值的反正切
public static double toRadians(double angdeg); 将角度转换为弧度不精确
public static double toDegrees(double angrad); 将弧度转换为角度不精确

*2)指数函数方法
*Math类中与指数相关的函数方法：
*public static double exp(double a) 用于获取e的a次方，即取e^a
public static double log(double a) 用于取自然对数，即取lna的值
public static double log10(double a) 用于取底数为10的对数
public static double sqrt(double a) 用于取a的平方根，其中a的值不能为负值
public static double cbrt(double a) 用于取a的立方根
public static double pow(double a，double b) 用于取a的b次方

*3)取整函数方法
*public static double ceil(double a) 返回大于等于参数的最小整数
*public static double floor(double a) 返回小于等于参数的最大整数
*public static double rint(double a) 返回与参数最接近的整数，如果两个同为整数且同样接近，则结果取偶数
*public static int round(double a) 将参数加上0.5后返回与参数最近的整数
*public static long round(double a) 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整型
*

*4）取最大值、最小值、绝对值函数方法
*public static double max(double a,double b) 取a与b之间的最大值
*public static int min(int a,int b) 取a与b之间的最小值，参数为整数
*public static long min(long a,long b) 取a与b之间的最小值，参数为长整型
*public static float min(float a,float b) 取a与b之间的最小值，参数为浮点型
*public static double min(double a,double b) 取a与b之间的最小值，参数为双精度型
*public static int abs(int a) 返回整型参数的绝对值
*public static long abs(long a) 返回长整型参数的绝对值
*public static float abs(float a) 返回浮点型参数绝对值
*public static double abs(double a) 返回双精度型参数的绝对值

3.随机数***
1）Math.random()方法
这个方法默认生成大于等于0.0且小于1.0的double型随机数，即0<=Math.random()<1.0,
虽然Math.random()方法只可以产生0~1之间的double型数字，其实只要在Math.random()语句上处理
就可以产生任意范围的随机数
public class 数学运算
{
/**
- 定义产生偶数的方法
- @param num1 起始范围参数
- @param num2 终止范围参数
- @return 随机的范围内的整数
  (斜杠)
  public static int GetEvenNum (double num1,double num2)
  {
  //产生num1~num2之间的随机数
  int s = (int)num1+(int)(Math.random()(num2-num1));
  if(s%2==0)
  {
  //判断随机数是否为偶数
  //返回
  return s;
  }
  else
  //如果是奇数
  return s+1; //将结果加1后返回
  }
  public static void main(String[] args)
  {
  //调用产生随机是方法
  System.out.println(“任意一个2~32之间的偶数：”+GetEvenNum(2,32));
  }
  }
  以上格式：(char)(‘a’+Math.random()*(‘z’-‘a’+1));
总的格式：(char)(cha1+Math.random()*(cha2-cha1+1));
public class 数学运算
{
//定义获取任意字符之间的随机字符
public static char GetRandomChar(char cha1,char cha2)
{
return (char)(cha1+Math.random()*(cha2-cha1+1));
}
public static void main(String[] args)
{
//获取a~z之间的随机字符
System.out.println(“任意小写字符”+GetRandomChar(‘a’,‘z’));
//获取A~Z之间随机字符
System.out.println(“任意大写字符”+GetRandomChar(‘A’,‘Z’));
//获取0~9之间的随机字符
System.out.println(“0到9任意数字字符”+GetRandomChar(‘0’,‘9’));
}
}

2)Random类
java中还提供了一种可以获取随机数的方式：
java.util.Random类，可以通过实例化一个Random对象创建一个随机数生成器
语法：Random r = new Random(); //r为Random的对象
也可以在实例化Random类对象时，设置随机数生成器的种子
语法：Random r = new Random(seedValue);
r:Random的对象
seedValue：随机数生成器的种子
在Random类中提供了获取各种数据类型随机数的方法：
public int nextInt() 返回一个随机整数
public int nextInt(int n) 返回大于等于0且小于n的随机整数
public long nextLong() 返回一个随机长整型值
public boolean nextBoolean() 返回一个随机布尔型值
public float nextFloat() 返回一个随机浮点型值
public double nextDouble() 返回一个双精度型值
public double nextGaussian() 返回一个概率密度为高斯分布的双精度值

3）BigInteger
超级大的整数运算
超过long取整范围整数，封装成BigInteger

BigInteger对象的四则运算
调用方法运算，计算结果也只能是BigInteger对象
public BigInteger add(BigInteger val) 做加法运算
public BigInteger subtract(BigInteger val) 做减法运算
public BigInteger multiply(BigInteger val) 做乘法运算
public BigInteger divide(BigInteger val) 做除法运算
public BigInteger remain(BigInteger val) 做取余操作
public BigInteger[] divideAndRemainder(BigInteger val) 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数
public BigInteger pow(int exponent) 进行取参数的exponent次方操作
public BigInteger negate() 取相反数
public BigInteger shiftLeft(int n) 将数字左移n位，如果n为负数，做右移操作
public BigInteger ShiftRight(int n) 将数字右移n位，如果n为负数，做左移操作
public BigInteger and(BigIngeter val) 做与操作
public BigInteger or(BigIngeter val) 做或操作
public int compareTo(BigIngeter val) 做数字比较操作
public boolean equals(Object x) 当参数x是BigInteger类型的数字并且数值相等时，返回true
public BigInteger min(BigIngeter val) 返回较小的数值
public BigInteger max(BigIngeter val) 返回较大的数值

4)BigDecimal(支持小数)

public BigDecimal(double val) 实例化时将双精度型转换为BigDecimal类型
public BigDecimal(String val) 实例化时将字符串形式转换为BigDecimal类型
可用来做超大数的四则运算（除法在除不尽的情况下末位小数点的处理是需要考虑的）
public BigDecimal add(BigDecimal augend) 加法
public BigDecimal subtract(BigDecimal subtrahend) 减法
public BigDecimal multiply(BigDecimal multiplylicand) 乘法
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) 除法三个参数分别代表
除数，商的小数点后的位数，近似处理模式

例
*/
import java.math.BigDecimal;

public class 数学运算{
static final int location = 10;
/**
* 定义加法方法，参数为加数与被加数
*
* @param value1 相加的第一个数
* @param value2 相加的第二个数
* @return 两数之和
/
public BigDecimal add(double value1,double value2) {
//实例化Decimal对象
BigDecimal b1 = new BigDecimal(Double.toString(value1));
BigDecimal b2 = new BigDecimal(Double.toString(value2));
return b1.add(b2);//调用加法方法
}
/*
* 定义减法方法，参数为减法与被减数
* @param value1 被减数
* @param value2 减数
* @return 运算结果
/
public BigDecimal sub(double value1,double value2) {
BigDecimal b1 = new BigDecimal(Double.toString(value1));
BigDecimal b2 = new BigDecimal(Double.toString(value2));
return b1.subtract(b2); //调用减法方法
}
/*
* 定义乘法方法，参数为乘法与被乘数
* @param value1 第一个乘数
* @param value2 第二个乘数
* @return 运算结果
/
public BigDecimal mul(double value1,double value2) {
BigDecimal b1 = new BigDecimal(Double.toString(value1));
BigDecimal b2 = new BigDecimal(Double.toString(value2));
return b1.multiply(b2);
}
/*
* 定义除法方法，参数为除法与被除数
* @param value1 被除数
* @param value2除数
* @return 运算结果
*/
public BigDecimal div(double value1,double value2) {
return div(value1,value2,location); //调用自定义除法方法
}
//定义除法方法，参数分别为除数与被除数以及商小数点后的位数
public BigDecimal div(double value1,double value2,int b) {
if(b<0) {
System.out.println(“b值必须大于等于0”);
}
BigDecimal b1 = new BigDecimal(Double.toString(value1));
BigDecimal b2 = new BigDecimal(Double.toString(value2));
//调用除法方法，商小数后保留b位，并将结果进行四舍五入操作
return b1.divide(b2,b,BigDecimal.ROUND_HALF_UP);
}
public static void main(String[] args)
{
数学运算 b = new 数学运算();
System.out.println(“两个数相加结果：”+b.add(-7.5, 8.9));
System.out.println(“两个数相减结果：”+b.sub(-7.5, 8.9));
System.out.println(“两个数相乘结果：”+b.mul(-7.5, 8.9));
System.out.println(“两个数相除，保留小数后10位：”+b.div(10, 2));
System.out.println(“两个数相除,保留小数后5位：”+b.div(-7.5, 8.9,5));
}
}

17.重载和覆盖就是函数的多态体现
1.多态的体现

父类的引用指向了自己的子类对象
父类的引用也可以接受自己的子类对象
2.多态的前提
必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提，存在覆盖
3.多态的好处
多态的出现大大的提高程序的扩展性
4.多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员

5.多态的出现代码中的特点（多态使用的注意事项）
转型
Animal a = new Cat();//类型提升也叫向上转型
a.eat();
如果想要调用猫的特有方法时，如何操作？
强制将父类的引用转成子类类型
Cat c = (Cat)a;
c.catchMouse();
千万不要出现这样的操作，就是将父类对象转成子类类型
我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换
多态自始至终都是子类对象在做着变化*/

向下转型
自始至终都是子类对象在做着变化

6.在多态中成员函数的特点：（常用）
在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败
在运行时期：参阅对象所属的类中是否有调用的方法
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边

*在多态中，成员变量的特点：
*当父类子类出现重名对象时，无论编译和运行，都参考左边（引用型变量所属的类）
*
*在多态中，静态成员函数的特点：
无论编译和运行，都参考左边（引用型变量所属的类）

7.public static void function(Animal a) //Animal a =new Cat();
{
a.eat();///200560929783
if(a instanceof Cat) //1.子类有限的 2.当传的类型需要进行其他操作必须得确定是哪种子类型
//要调用哪种特有方法属性这两种情况可以用instanceof
{Cat c = (Cat)a;
c.catchMouse();}
else if (a instanceof Dog)
{
Dog c = (Dog)a;
c.kanJia();
}
}
七、包装类
1.Integer
compareTo(Integer anotherInteger)在数字上比较两个Integer对象，
如果这两个值相等，返回0，如果调用对象的数值小于anotherInteger的数值，
则返回负值，如果调用对象的数值大于anotherInteger的数值，则返回正值
toString()返回一个表示该Integer的值得String对象十进制
toBinaryString() 转换成二进制
toHexString() 转换成十六进制
toOctalString() 转换成八进制
valueOf(String str)返回保存指定的String值的Integer对象
parseInt(String str)返回包含在由str指定的字符串中的数字的等价整数值
常量：
MAX_VALUE:表示int类型可取的最大值
MIN_VALUE:表示int类型可取的最小值
SIZE:用来以二进制补码形式表示int值的位数
TYPE:表示基本int的Class实例
2.boolean
equals(Object obj)判断调用该方法的对象与obj是否相等，当且仅当参数不是null，
而且与调用该方法的对象一样都表示同一个boolean值的Boolean对象时，才返回true
3.Character
compareTo(Character anotherCharacter)根据数字比较两个Character对象，若这两个对象相等则返回0
toUpperCase(char ch) 将字符参数转换为大写
toLowerCase(char ch)将字符参数转换为小写
isUpperCase(char ch)判断指定字符是否为大写字符
isLowerCase(char ch)判断指定字符是否为小写字符
表示特定字符的常量：
CONNECTOR_PUNCTUATION:返回byte型值，表示Unicode规范中的常规类别"Pc"
UNASSIGNED:返回byte型值，表示Unicode规范中的常规类别"Cn"
TITLECASE_LETTER:返回byte型值，表示Unicode规范中的常规类别"Lt"
4.Double
常量
MAX_EXPONENT:返回int值，表示有限double变量可能具有的最大指数
MIN_EXPONENT:返回值int值，表示标准化double变量可能具有的最小指数
NEGATIVE_INFINITY:返回double值，表示保存double类型的负无穷大值的常量
POSITIVE_INFINITY:返回double值，表示保存double类型的正无穷大值的常量
5.抽象类Number是BigDecimal、BigInteger、Double、Float、Integer、Long和Short类的父类，
Number的子类必须提供将表示的数值转换为byte.double.float.int.long和short的方法

八、数字处理类
在java中没有格式化的数据遵循以下原则：
如果数据绝对值大于0.001并且小于10000000，java将以常规小数形式表示
如果数据绝对值小于0.001或大于10000000，使用科学计数法表示

*在java中可以使用DecimalFormat类进行格式化操作
*DecimalFormat是NumberFormat的一个子类，用于格式化十进制的数字，他可以将一些数字格式化为整数，浮点数，百分数等
*通过使用该类可以为输出的数字加上单位或控制数字的精度，一般情况下可以在实例化DecimalFormat对象是传递数字格式，
*也可以通过DecimalFormat类中的applyPattern()方法来实现数字格式化
*当格式化数字时，在DecimalFormat类中使用一些特殊字符构成一个模式化模板，使数字按照一定的特殊字符规则进行匹配
*
*在DecimalFormat类中还可以使用一些特殊方法对数字进行格式化设置
*setGroupingSize()方法设置格式化数字的分组大小，setGroupingUsed()方法设置是否可以对数字进行分组操作
例：
import java.text.DecimalFormat;
public class DecimalMethod{
public static void main(String[] args) {
DecimalFormat myFormat = new DecimalFormat();
myFormat.setGroupingSize(2); //设置将数字分组为2
String output = myFormat.format(123456.789);
System.out.println(“将数字以每两个数字分组”+output);
myFormat.setGroupingUsed(false); //设置不允许数字进行分组
String output2 = myFormat.format(123456.789);
System.out.println(“不允许数字分组”+output2);
}
}

import java.text.DecimalFormat; /*将java.text.DecimalFormat这个类包含进来，这是首先告知系统下面的代码将使用
到DecimalFormat类，然后定义两个格式化数字的方法，这两个方法的参数个数都为两个，分别代表数字格式化模板和具体需要
格式化的数字，虽然这两个数字的方法都可以实现格式化数字的操作，但使用的方式有所不同，SimgalFormat()方法是在实例
化DecimalFormat对象时设置数字格式化模板，而UseApplyPatternMethodFormat（）方法是在实例化DecimalFormat对象后调
用applyPattern()方法设置数字格式化模板，最后在主方法中根据不同形式模板格式化数字，当数字某位不存在时，将显示0；
而以“#”特殊字符构成的模板进行格式化操作时，格式化后的数字位数与数字本身的位数一致
*/

public class 包装类 {
//使用实例化对象时设置格式化模式
static public void SimgleFormat(String pattern,double value)
{
//实例化DecimalFormat对象
DecimalFormat myFormat = new DecimalFormat(pattern);
String output = myFormat.format(value); //将数字进行格式化
System.out.println(value+" “+pattern+” “+output);
}
//使用applyPattern()方法对数字进行格式化
static public void UseApplyPatternMethodFormat(String pattern,double value)
{
DecimalFormat myFormat = new DecimalFormat(); //实例化DecimalFormat对象
myFormat.applyPattern(pattern); //调用applyPattern（）方法设置格式模板
System.out.println(value+” “+pattern+” "+myFormat.format(value));
}

public static void main(String[] args) {
// TODO Auto-generated method stub
SimgleFormat("###,###.###",123456.789); //调用静态SimgleFormat()方法
SimgleFormat(“00000000.###kg”,123456.789);//在数字后加上单位
//按照格式模板格式化数字，不存在的位以0显示
SimgleFormat(“000000.000”,123.78);
//调用静态UseApplyPatternMethodFormat（）方法
UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式
//将小数点后格式化为两位
UseApplyPatternMethodFormat("###.##",123456.789);
//将数字转化为千分数形式
UseApplyPatternMethodFormat(“0.00\u2030”,0.789);
}
}

九、类的特性

1.内部类
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类、嵌套类）（一个类里可以定义多个内部类）
访问特点：

1）内部类可以直接访问外部类中的成员，包括私有
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，
格式：外部类名.this
class Outer
{
private int x = 3;

class Inner //内部类 private class Inner 内部类可以被私有修饰，当内部类在外部类的成员位置时可被私有修饰
{
int x =4;

void function()
{
int x =6;
System.out.println(“inner:”+x); //结果：6 内部有不出去找
//System.out.println(“inner:”+this.x); //结果：4
//System.out.println(“inner:”+Outer.this.x); //结果：3
}
}
void method()
{
//System.out.println(x);
Inner in = new Inner();
in.function();
}
}

public class 内部类 {

public static void main(String[] args) {
// TODO Auto-generated method stub
Outer out = new Outer();
out.method();

//直接访问内部类中的成员
Outer.Inner in = new Outer().new Inner(); //格式
in.function();
}
}

2）而外部类要访问内部类中的成员必须要建立内部类的对象
访问格式：
当内部类定义在外部类的成员位置上，而且非私有，在外部其他类中，可以直接建立内部类对象
格式：
外部类名.内部类名变量名 = 外部类对象.内部类对象;Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上，就可以被成员修饰符所修饰
比如，private：将内部类在外部类中进行封装
static：内部类可以被静态修饰内部类就具备了static的特性（出现次数不是很多）
当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限
在外部其它类中,如何直接访问static内部类的非静态成员？
new Outer.Inner().function();
在外部其它类中,如何直接访问static内部类的静态成员？（使用频率低）
Outer.Inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static的
当外部类中的静态方访问内部类时，内部类必须也是static的
当描述事物时，事物的内部还有事物，该事物用内部类来描述
因为内部事务在使用外部事物的内容
内部类可以写在外部类的任意位置上成员也包括局部
局部内部类不能定义静态成员，不能被静态私有修饰
内部类能直接访问外部类中成员的具体事物一般用于程序设计上

/****************************************************************************************/
/*内部类定义在局部时，

1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类中的引用
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量
*/
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(a);
}

}
new Inner().function();
}
}

public class lilili {

public static void main(String[] args) {
// TODO Auto-generated method stub
//new Outer().method(7);
//new Outer().method(8);
Outer out = new Outer();
out.method(7);
out.method(8);
}

}

2.匿名内部类：

1.匿名内部类其实就是内部类的简写格式(就是为了简化书写，覆盖方法)
2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
3.匿名内部类的格式： new 父类或者接口（）{定义子类的内容}
4.其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象
5.匿名内部类中定义的方法最好不要超过三个

abstract class AbsDemo
{
abstract void show();
}

class Outer1
{
int x = 3;
/class Inner extends AbcDemo
{
void show()
{
System.out.println(“show”+x);
}
}/
public void function()
{
//new Inner().show();

new AbsDemo() //带着内容的对象
{
void show()
{
System.out.println(“x=”+x);
}
void abc()
{
System.out.println(“haha”);
}
}.abc();

AbsDemo d = new AbsDemo()
{
int num= 90;
void show()
{
System.out.println(“x==”+x);
System.out.println(“num==”+num);
}
};
d.show();
//d.abc(); 不行，编译错误因为父类中没有这种方法匿名内部类的局限
}
public class 匿名内部类 {

public static void main(String args[]) {
// TODO Auto-generated method stub
new Outer1().function();
}
}

/******************************************************************************************/

public class 匿名内部类 {

public static void main(String args[]) {
// TODO Auto-generated method stub

//Test.function():Test类中有一个静态的方法function
//.method（）：function这个方法运算后是一个对象，而且是一个Inter类型的对象
//因为只有是Inter类型的对象，才可以调用method方法

Test.function().method();

show(new Inter()
{
public void method()
{
System.out.println(“method show run”);
}
});
}

public static void show(Inter in) //当使用的参数类型是接口类型时，接口类型里的方法不超过三个
//可以定义匿名内部类，把匿名内部类作为参数传进去
{
in.method();
}
}

3.异常

异常的体系
Throwable
Error
通常出现重大问题如：运行的类不存在或者内存溢出等
不编写针对代码对其处理
Exception 和Error的子类名都是以父类名作为后缀
异常：就是程序运行时出现的不正常情况
异常由来：问题也是现生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象
即把问题封装成对象就是异常
其实就是java对不正常情况进行描述后的对象体现
对于问题的划分：
一种是严重的问题：java通过Error类进行描述
对于Error不编写针对性的代码对其进行处理
一种是非严重的问题：java通过Exception类进行描述
对于Exception可以使用针对性的处理方式进行处理
1.无论Error或者Exception都具有一些共性内容
比如：不正常情况的信息，引发原因等
Throwable 是java语言中所有错误或异常的超类（父类）
2.异常的处理
java提供了特有的语句进行处理
固定的格式：
try
{
*需要被检测的代码
}
catch(异常类变量)
{
处理异常的代码；（处理方式）
}
finally
{
一定会执行的语句；
}
3.对捕获到的异常对象进行常见方法操作
String getMessage():获取异常信息
在函数上声明异常
便于提高安全性，让调用出进行处理，不处理编译失败
对多异常的处理
1.声明异常时，建议声明更为具体的异常，这样处理的可以更为具体
2.对方声明几个异常，就对应有几个catch块，不要定义多余的catch块
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
建议在进行catch处理时，catch中一定要定义具体处理方式
不要简单定义一句e.printStackTrace(),
也不要简单的就书写一条输出语句
class Demo{
int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException //在功能上通过throws的关键字声明了该功能有可能会出现的问题
//在程序中声明两个异常

{
int [] arr = new int[a];
System.out.println(arr[4]);

return a/b;
//函数中有异常情况发生只要是没有处理那个异常，这个函数就停止执行了

}
}

public class 异常 {

public static void main(String[] args) // throws Exception //把问题抛给虚拟机
{
// TODO Auto-generated method stub
Demo d = new Demo();
try
{
int x = d.div(4,0);
System.out.println(“x=”+x);

}
catch(Exception e)
{
System.out.println(“hahah:”+e.toString());
}
/*//声明几个就得有几个对应的处理
catch(ArithmeticException e)
{
System.out.println(e.toString());
System.out.println(“被零除了！！”);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println(“角标越界！！！”);
}
System.out.println(“over”);
*/
}

}

/*class Demo{
int div(int a,int b)
{
return a/b;
}
}

public class 异常 {

public static void main(String[] args) {
// TODO Auto-generated method stub
Demo d = new Demo();
try
{
int x = d.div(4,1); //没问题的情况下catch不处理，不走catch
System.out.println(“x=”+x);
}
catch(Exception e) //Exception e = new ArithmeticException();
{
System.out.println(“除零啦”);

System.out.println(e.getMessage()); // / by zero 提取异常信息
System.out.println(e.toString()); // 异常名称：异常信息
e.printStackTrace(); //打印异常名称，异常信息，异常出现的位置
//其实jvm默认的异常处理机制，就是在调用printStackTrace方法
//打印异常的堆栈的跟踪信息

}

System.out.println(“over”);

}

}*/

4.finally
数据库服务器处理的连接是有限的
finally代码块：定义一定执行的代码

通常用于关闭资源
第一个格式：
try
{
正常流程代码
}
catch() //问题
{
问题代码
}
第二个格式：
try{
}
catch()
{
}
finally
{
}
第三个格式：
try
{
}
finally
{
}
*/

/*记住：

catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明

/*异常在子父类覆盖中的体现：

1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或该异常的子类或者不同
2.如果父类方法抛出多个异常，那么子类在覆盖该方法时只能抛出父类异常的子集
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常

 如果子类方法发生了异常，就必须要进行try处理，绝对不能抛

*/
class AException extends Exception
{

}
class BException extends AException
{

}
class CException extends Exception
{

}
/*Exception

|–AException
|–BException
|–CExpection*/
class Fu
{
void show()throws AException
{

}
}

class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch(AException e)
{
//早期程序不能处理后期产生的新异常所以现在子类中抛出CException是错误的
}
}
}
class zi extends Fu
{
void show()throws CException //不能抛CException，可以抛AException和BException 因为父类中没有这个错误子类不能抛新异常
{
//子类中出现的新异常不能抛只能try
//如果子类真出现C异常必须在内部处理，不能抛
}
}
public class 异常2
{
public static void main(String[] args)
{
Test t = new Test();
t.function(new Zi());
}
}
5.自定义异常
因为项目中会出现特有的问题

而这些问题并未被java所面熟并封装对象
所以对于这些特有的问题可以按照java的对问题封装的思想
将特有的问题，进行自定义的异常封装
自定义异常：

/*需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的

那么就需要对这个问题进行自定义的描述
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作
要么在内部try catch处理
要么在函数上声明让调用者处理
一般情况下，函数内出现异常，函数上需要声明
发现打印的结果中只有异常的名称，却没有异常的信息
因为自定义的异常并未定义所属信息
如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了
所以子类只要在构造时将异常信息传递给父类通过super语句
那么就可以直接通过getMessage方法获取自定义的异常信息
自定义异常：
必须是自定义类继承Exception
继承Exception原因：
异常体系有一个特点：
因为异常类和异常对象都需要被抛出
他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点
只有这个体系中的类和对象才可以被throws和throw操作
只有继承Exception、Error或Throwable才可抛
（必须得在那个体系中）
throw和throws 的区别：
throws使用在函数上（小括号和大括号之间），后面跟异常类可以跟多个，用逗号隔开
throw使用在函数内，后面跟的是异常对象
*/

class FuShuException extends Exception //getMessage
{
/private String msg;
FuShuException(String msg)
{
this.msg = msg;
}
public String getMessage()
{
return msg;
}/
private int value;

FuShuException()
{
super();
}
FuShuException(String msg,int vlaue)
{
super(msg);
this.value = value;
}
public int getValue()
{
return value;

}

class Demo
{
int div(int a,int b)throws FuShuException //函数上的声明
{
if(b<0)
throw new FuShuException(“出现了除数是负数的情况/by fushu”,b); //手动通过throw关键字抛出一个自定义异常对象

return a/b;
}
}
public class Exception1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
Demo d = new Demo();
try
{
int x = d.div(4, -1);
System.out.println(“x=”+x);

}
catch (FuShuException e)
{
System.out.println(e.toString());
//System.out.println(“除数出现负数了”);
System.out.println(“错误的负数是：”+e.getValue());
}
System.out.println(“over”);
}
}

qq_43308791

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
初学Java（4）

六、面向对象15.Object 是类层次结构的根类，每个类都使Object作为超类，所有对象（包括数组）都实现这个类的方法是所有对象的直接或间接父类，传说中的父类该类中定义的肯定是所有对象都具备的功能在object类中主要包括clone(),finalize(),equals(),toString()等方法，其中常用的两个方法为equals()和toStrong() 方法，由于所有的...
复制链接

扫一扫