黑马程序员——第十天(Java面向对象-异常-包)

时间:2021-11-11 11:52:48

---------------------- android培训java培训、期待与您交流! ----------------------

一.面向对象(异常-finally)

extends Exception 声明编译时被检测异常

如果声明的是编译时异常  所以需要在函数上  用  throws进行标识


finally代码块:定义一定执行的代码

通常用于关闭资源。


只要调用资源,就一定要做关闭资源的动作

Java语言 创建文件  是怎么完成的?

Windows本身有这个动作 ,Java就不用去做了,Java就调用底层Windows资源就可以了 


二.面向对象(异常-处理语句其他格式)

第一个格式:

try{

}catch(){

}

第二个格式:

try{

}catch(){

}finally{

}

第三个格式:

try{

}finally{

}

原则:只要问题被解决(catch)  就不用声明出去  
    问题没有被解决  就需要在函数上声明


记住一点:catch是用于处理异常,如果没有catch就代表异常没有被处理过,

如果该异常是检测时异常,那么必须声明  


三.面向对象(异常-覆盖时的异常特点)

异常在子父类覆盖中的体现:

1.子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法只能抛出异常或者该异常的子类 或者  不抛

不能抛父类中没有的异常

2.如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集

3.如果父类或者接口的方法中,没有异常抛出那么子类在覆盖方法时也不可以抛出异常

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


四.面向对象(异常-练习)

写代码的时候会经常碰到问题 

碰到问题怎么办?

全用异常描述  进行封装对象 

问题也是个对象  万物皆对象

/*

有一个圆型和长方形
都可以获取面积,对于面积 如果出现非法的数值,视为获取面积时出现的问题
问题通过异常来表示

注意:
先要对这个程序进行基本设计

正常流程代码 和 问题处理代码 结合非常大紧密 阅读性非常的差
异常的产生 可以让正常流程代码 和 问题处理代码 相分离

*/
class NoValueException extends RuntimeException{
NoValueException(String message){
super(message);
}
}
interface Shape{
void getArea();
}
class Rec implements Shape{
private int len,wid;
Rec(int len, int wid){
if(len <= 0 || wid <= 0)
throw new NoValueException("出现非法值");

this.len = len ;
this.wid = wid ;
}
@Override
public void getArea() {

System.out.println(len * wid);
}

}
class Circle implements Shape{
private double radius ;
Circle(double radius){
if(radius <= 0)
throw new NoValueException("出现非法值");
this.radius = radius;
}
@Override
public void getArea() {
System.out.println(Math.PI * Math.pow(radius, 2.0));
}

}

public class ExceptionTest1 {
public static void main(String[] args) {
//Rec rec = new Rec(-3, 4);
//rec.getArea();
Circle circle = new Circle(-2.0);
circle.getArea();
System.out.println("Over");
}
}

五,面向对象(异常-总结)

异常: 

是什么?是对问题的描述,将问题进行对象的封装

--------------------------------------------------------------------------------------------------------------------------

异常体系:

Throwable

|--Error

|--Exception

|--RuntimeException

异常体系的特点:异常体系中的所有类以及建立的对象 都具备可拋性,

也就是说可以被throw  throws关键字所操作。

只有异常体系具备这个特点

--------------------------------------------------------------------------------------------------------------------------

throw和throws的用法:

throw定义在函数内部 用于抛出异常对象

throws定义在函数上 用户抛出异常类 ,可以抛出多个 用逗号隔开


当函数内有throw抛出异常对象,并未进行try处理,必须要在函数上声明,否则编译失败

注意:RuntimeException除外,也就是说,函数内如果抛出的是RuntimeException异常,函数上可以不用声明

--------------------------------------------------------------------------------------------------------------------------

如果函数声明了异常,调用者需要进行处理,处理方式可以throw可以try


异常有两种,

编译时被检测异常 (javac)

该异常在编译时,如果没有处理(没有抛也没有try),那么编译失败

该异常被标识,代表着可以被处理

运行时异常(编译时不检测)

在编译时,不需要处理,编译器不检查

该异常发生,建议不处理,让程序停止,需要对代码进行修正。

--------------------------------------------------------------------------------------------------------------------------

异常处理的语句:

try{

需要被检测的代码;

}catch{

处理异常的代码;

}finally{

一定会执行的代码;

}

有三个执行格式:

1.try{

}catch

2.try{

}catch{

}finally{

}

3.

try{

}finally{

}

注意:

1.finally中定义的通常是 关闭资源代码  因为资源必须释放

2.finally只有一种情况不会执行 当执行到 System.exit(0);系统退出(JVM结束) finally不会执行

--------------------------------------------------------------------------------------------------------------------------

自定义异常:

定义类继承Exception 或者 RuntimeException

1.为了让该自定义类具备可拋性

2.让该类具备操作异常的共性方法

当要定义自定义异常的信息时,可以使用父类已经定义好 的功能

将异常信息传递给父类的构造函数

class MyException extends Exception{

MyException(String message){

super(message);

}

}

自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装

--------------------------------------------------------------------------------------------------------------------------


异常的好处:

1.将问题进行封装成对象

2.将正常流程代码和问题处理代码相分离,方便于阅读


异常的处理原则:

1.处理方式有两种:try 或者 throws

2.调用到抛出异常的功能时,抛出几个,就处理几个

一个try对应多个catch

3.多个catch,父类的catch放到最下面

4.catch内需要定义针对性的处理方式,不要简单的定义printStackTrace(),输出语句。

也不要不写,

当捕获到的异常,本功能处理不了时,可以继续在catch中抛出

try{

throw new AExcepton();

}catch(AExcepton e){

throw e ;

}

如果该异常处理不了,但并不属于该功能出现的异常

可以将异常转换后,再抛出和该功能相关的异常

或者异常可以处理,当需要将异常产生的和本功能提供的问题提供出去,

让调用者知道,并处理,也可以将捕获异常处理后,转换新的异常。

try{

throw new AExcepton();

}catch(AExcepton e){

//对AException处理

throw new BException() ;

}

比如:汇款的例子。


异常的注意事项:

在子父类覆盖时:

1.子类抛出的异常必须是父类异常的子类或者子集

2.如果父类或者接口没有异常抛出时,子类覆盖出现异常 只能try不能抛


六.面向对象(练习四)

//1.写出程序结果
class Demo{
public static void func()/*throws Exception*/{
try{
throw new Exception();
}finally{
System.out.println("B");
}
}
public static void main(String [] agrs){
try{
func();
System.out.println("A");
}catch(Exception e){
System.out.println("C");
}
System.out.println("D");
}
}
//编译失败
//如果func()上声明了该异常,结果是:B C D

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

//写出程序结果
class Test{
Test(){
System.out.println("Test");
}
}
class Demo extends Test{
Demo(){
//super();有一个隐身的构造函数
System.out.println("Demo");
}
public static void mian (String [] args){
new Demo();
new Test();
}
}
//Test Demo Test
//考的是子类的实例化过程

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

//3.写出程序结果

interface A{}
class B implements A{
public String func(){
return "func";
}
}
class Demo {
public static void main(String[] args){
A a = new B();
System.out.println(a.func());
}
}

//编译失败,因为A接口中并未定义func方法

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

//4.写出程序结果
class Fu{
boolean show(char a){
System.out.println(a);
return true ;
}
}
class Demo extends Fu{
public static void main(String[] args){
int i = 0 ;
Fu f = new Demo();
Demo d = new Demo();
for(f.show('A') ; f.show('B') && (i < 2) ; f.show('C')){
i++;
d.show('D');
}
}
boolean show(char a){
System.out.println(a);
return false ;
}
}
//A B

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

//5.写出程序结果
interface A{}
class B implements A{
public String test(){
teturn "yes";
}
}
class Demo{
static A get(){
return new B();
}
public static void main(String [] args){
A a = get();
System.out.pringln(a.test());
}
}
// 编译失败:因为A接口中没有定义test方法

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

//6.写出程序结果:
class Super{
int i = 0 ;
public Super(String a){
System.out.println("A");
i = 1 ;
}
public Super(){
System.out.println("B");
i += 2 ;
}
}
class Demo extends Super{
public Demo(String a){
//super();
System.out.println("C");
i = 5 ;
}
public static void main(String [] args){
int i = 4 ;
Super d = new Demo("A");
System.out.println(d.i);
}
}
//B C 5

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

//7.
interface Inter{
void show(int a , int b);
void func();
}
class Demo{
public static void main(String [] args){
//补足代码:调用两个函数,要求用匿名内部类
}
}
/*
Inter inter = new Inter(){
public void show(int a , int b){

}
public void func(){

}
};
inter.show(3 , 5);

inter.func();

*/

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

//8.写出程序结果
class TD{
int y = 6 ;
class Inner{
static int y = 3 ;
void show(){
System.out.println(y);
}
}
}
class TC{
public static void main(String [] args){
TD.Inner ti = new TD().new Inner();
ti.show();
}
}
//编译失败,非静态内部类不可以定义静态成员
//内部类中如果定义了静态成员,该内部类必须被静态修饰。

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

//9.选择题:写出错误答案错误的原因,用单行注释的方式。
class Demo{
int show(int a , int b){return 0 ;}
}
/*
下面哪些函数可以存在于Demo的子类中
A.public int show(int a, int b){return 0 ;}//可以,覆盖
B.private int show(int a, int b){return 0 ;}//不可以,子类覆盖父类的方法 权限不能比父类的小
C.private int show(int a, long b){return 0 ;}//可以,和父类不是一个函数,没有覆盖,相当于重载
D.public short show(int a, int b){return 0 ;}//不可以,因为该函数不可以和给定函数出现在同一类中 或者子父类中
E.static int show(int a, int b){return 0 ;}//不可以,静态只能覆盖静态。

*/

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

//10.写出this关键字的含义,final有哪些特点?
/*
this:代表本类对象,哪个对象调用this所在函数,this就代表哪个对象
final:
1.修饰类,变量(成员变量,静态变量,局部变量),函数
2.修饰类不可以被继承
3.修饰的函数不可以被覆盖
4.修饰的变量是一个常量,只能赋值一次
5.内部类只能访问局部当中final修饰的局部变量


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

//写出程序结果
class Fu{
int num = 4 ;
void show(){
System.out.println("showFu");
}
}
class Zi extends Fu{
int num = 5 ;
void show(){
System.out.println("showZi");
}
}
class T{
public static void main(String[] args){
Fu f = new Zi();
Zi z = new Zi();
System.out.println(f.num);
System.out.println(z.num);
f.show();
z.show();
}
}
/*变量不存在覆盖 是随着类走的 成员变量看左边
4
5
showZi
showZi
*/

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

//12.
interface A{
void show();
}
interface B{
void add(int a , int b );
}
class C implements A,B{
//程序代码
}
class D{
public static void main(String[] args){
C c = new C();
c.add(4,2);
c.show();//通过该函数打印以上两个数的和。
}
}
/*
private int a , b ;
public void add(int a , int b){
this.a = a ;
this.b = b ;
}

public void show(){
System.out.println(a+b);
}
*/

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

//13.写出程序结果
class Demo{
public static void main(String[] args){
try{
showExce();
System.out.println("A");
}catch(){
System.out.println("B");
}finally{
System.out.println("C");
}
System.out.println("D");
}
public static void showExce()throws Exception{
throw new Exception();
}
}

//B C D

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

//14.写出程序结果
class Super
{
int i = 0 ;
public Super(String s){
i = 1 ;
}
}
class Demo extends Super
{
public Demo(String s){
i = 2 ;
}
public static void main(String[] args){
Demo d = new Demo("Yes");
System.out.println(d.i);
}
}
//编译失败,因为父类中缺少空参数的构造函数
//或者子类应该通过super语句指定要调用的父类中的构造函数

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

//15.写出程序结果
class Super
{
public int get(){return 4 ;}
}
class Demo15 extends Super
{
public long get(){return 5 ;}
public static void main(String[] args){
Super s = new Demo15();
System.out.println(s.get());
}
}
//编译失败,因为子父类中的get方法没有覆盖,但是子类调用的时候不能明确返回的值是什么类型
//所以这样的函数不可以存在于子父类中

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

//16.写出程序结果

class Demo
{
public static void func(){
try
{
throw new Exception();
System.out.println("A");
}
catch (Exception e)
{
System.out.println("B");
}
}
public static void main(String[] args){
try
{
func();
}
catch (Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
// 编译失败。因为打印“A”的输出语句执行不到 就像return下面不能放语句一样 可以看到13题
//记住 throw单独存在时 下面不要定义语句 ,因为执行不到
//continue break return 下面都不可以定义语句

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

//17.
class Demo
{
public void func(){
//位置1

}
class Inner{}
public static void mian(String[] args){
Demo d = new Demo();
//位置2
}
}
A.在位置1写 new Inner();//OK 外部类 访问 内部类 需要new对象
B.在位置2写 new Inner();//不可以 主函数的静态的,如果要访问 Inner需要被静态修饰
C.在位置2写 new d.Inner();//错误 格式错误 new d.Inner() 还原一下 new new Demo().Inner();
D.在位置2写 new Demo.Inner();//错误 因为Inner不是静态的

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

//18.写出程序结果
class Exc0 extends Exception{}
class Exc1 extends Exc0{}
class Demo
{
public static void main(String[] args){
try
{
throw new Exc1();
}
catch (Exceptin e)
{
System.out.println("Exception");
}
catch (Exc0 e)
{
System.out.println("Exc0");
}
}
}
//编译失败。多个catch时 父类的catch要放在下面
/**************************************************************************************/

//19.
interface Test
{
void func();
}
class Demo
{
public static void main(String[] args){
//补足代码:(匿名内部类)

}
void show(Test t){
t.func();
}
}
/*不能直接调用show方法 因为主函数的静态的 因为show方式不是静态的 所以应该创建对象调用
new Demo().show(new Test(){
public void func
});

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

//20.写出程序结果
class Test
{
public static String output = "" ;
public static void foo(int i){
try
{
if(i == 1)
throw new Exception();
output += "1";
}
catch (Exception e)
{
output += "2";
return ;
}
finally
{
output += "3";
}
output += "4";
}
public static void main(String[] args){
foo(0);
System.out.println(output);
foo(1);
System.out.println(output);
}
}

//134
//13423

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

//21.建立一个图形接口,声明一个面积函数,圆形和矩形都实现了这个接口,并得出两个图形的面积
//注:体现面向对象的特征,对数值进行判断。用异常处理,不合法的数值要出现“这个数值是非法的”提示,不再进行运算。

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

//23.补足compare函数内的代码 ,不许添加其他函数
class Circle
{
private static double pi = 3.14;
private double radius;
public Circle(double r){
radius = r ;
}
public static double compare(Circle[] cir){
//程序代码//其实就是在求数组中的最大值
}
}
class TC
{
public static void main(String[] args){
Circle[] cir = new Circle[3];//创建了一个类类型数组
cir[0] = new Circle(1.0);
cir[1] = new Circle(2.0);
cir[2] = new Circle(4.0);
System.out.println("最大的半径是:" + Circle.compare(cir));

}
}
/*
int temp = 0;
for(int i = 1 ; i < cir.length ; i++){
temp = (cir[temp].radius > cir[i].radius)?temp:i ;
}
return cir[temp].radius;

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

//23.写出程序结果
public class Demo
{
private static int j = 0 ;
private static boolean methodB(int k){
j += k ;
return true ;
}
public static void methodA(int i){
boolean b ;
b = i < 10 | methodB(4);
b = i < 10 || methodB(8);
}
public static void main(String[] args){
methodA(0);
System.out.println(j);
}

}
// 4

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

/*
24.
假如我们在开发一个系统时需要对员工进行建模,员工包含3个属性;
姓名、工号、以及工资,经理也是员工,除了含有员工的属性外,
另外还有一个奖金属性。请使用继承的思想设计出员工类和经理类,
要求:类中提供必要的方法进行属性访问。
*/

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

/*
25.
在一个类中编写一个方法,这个方法搜索一个字符数组中是否存在某个字符。
如果存在,则返回这个字符在字符数组中第一次出现的位置(序号从0开始计算),
否则,返回-1,要搜索的字符数组和字符都以参数形式传递给该方法,
如果传入的数组为null,应抛出IllegalArgumentException异常。
在类的main方法中以各种可能出现的情况测试验证该方法编写的是否正确,
例如:字符不存在;字符存在,传入的数组为null等
getIndex(null,'a');
*/
public int getIndex(char[] arr , char key){
if(arr == null)
throw new IllegalArgumentException("数组为null");
for(int x = 0 ; x < arr.length ; x++){
if(arr[x] == key )
return x ;
}
return -1 ;
}

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

//26。补足compare函数内的代码,不许添加其他函数
class Circle
{
private double radius ;
public Circle(double r){
radius = r ;
}
public Circle compare(Circle cir){
//程序代码

}
}
class TC
{
public static void main(String[] args){
Circle cir1 = new Circle(1.0);
Circle cir2 = new Circle(2.0);
Circle cir ;
cir = cir1.compare(cir2);
if(cir1 == cir)
System.out.println("圆1的半径比较大");
else
System.out.println("圆2的半径比较大");
}
}
/*
return (this.radius > cir.radius)? this : cir ;

*/


七.面向对象(包 package)

1.对类文件进行分类管理

2.给类提供多层命名空间

3.卸载程序文件的第一行

4.类名的全称是  包名.类名

5.包也是一种封装形式


Java中的包  也就是系统文件 的 文件夹  

包名:所有的字母小写


NoClassFoundError

包的出现  可以将Java的类文件  与源文件想分离

当想使用一个包中的类时  classPath只要指向 包的父目录即可  


八.面向对象(包与包之间访问)

类名的全名是:包名.类名

有了包,范围变大,一个包中的类要被访问,必须要有足够大的权限

所以被访问的类要被public修饰


类共有后,被访问的成员也要公有才可以被访问

包 类 函数 也的封装  私有只是封装的一种形式


总结:

包与包之间进行访问,被访问的包中的类以及 类中的成员 需要public修饰

不同包中的子类还可以直接访问父类中被protected权限修饰的成员

包与包直接可以使用的权限只有两种,public protected(只能给子类使用)


public  protecteddefault private

同一个类中  ok ok    ok            ok

同一个包中  ok ok    ok

子类  ok ok

不同包中  ok

一个.java文件里  不能出现两个以上的 共用类或者 接口  


九.面向对象(导入-import)

为了简化类名的书写 ,使用一个关键字 : import

import 导入的是包中的类 而不包括里面的子包

建议,不要写通配符* 需要用到包中的哪个类,就导入哪个类

当导入不同包中的类 出现重名时,必须加包名


建议定义包名不要重复,可以使用url来完成定义,url是唯一的


十.面向对象(jar包)

jar包

Java的压缩包

方便项目的携带

方便于使用,只要在classpath设置jar路径即可

数据库驱动,SSH框架等都是以jar包体现的。


jar -cf haha.jar pack  打包

jar -tf haah.jar  查看目录

jar -tf a.jar >c:\1.txt    > 数据重定向   把目的地指定一下 

rt.java是java的类库 Java的对象 都在这里


关键字native 本地方法  

这个方法是看不见方法体的 因为这个方法在调用系统 


用法: jar {ctxui}[vfm0Me] [jar-file] [manifest-file] [entry-point] [-C dir] file

s ...
选项包括:
    -c  创建新的归档文件
    -t  列出归档目录
    -x  解压缩已归档的指定(或所有)文件
    -u  更新现有的归档文件
    -v  在标准输出中生成详细输出
    -f  指定归档文件名
    -m  包含指定清单文件中的清单信息
    -e  为捆绑到可执行 jar 文件的独立应用程序
        指定应用程序入口点
    -0  仅存储;不使用任何 ZIP 压缩
    -M  不创建条目的清单文件
    -i  为指定的 jar 文件生成索引信息
    -C  更改为指定的目录并包含其中的文件
如果有任何目录文件,则对其进行递归处理。
清单文件名、归档文件名和入口点名的指定顺序
与 "m"、"f" 和 "e" 标志的指定顺序相同。


示例 1:将两个类文件归档到一个名为 classes.jar 的归档文件中:
       jar cvf classes.jar Foo.class Bar.class
示例 2:使用现有的清单文件 "mymanifest" 并
           将 foo/ 目录中的所有文件归档到 "classes.jar" 中:
       jar cvfm classes.jar mymanifest -C foo/ .


---------------------- android培训java培训、期待与您交流! ----------------------