黑马程序员java培训就业班笔记day10总结.doc

黑马程序员java培训就业班笔记day10总结

资料仅供参考
Day10总结：
1、 多态的特点：
1、 成员变量：
当在子父类中出现了相同的非私有成员变量时，在多态调用中的特点：
在编译时：参考引用型变量所属类中是否有调用的成员变量，如果有编译经过，如果没有编译失败。
在运行时：参考引用型变量所属的类中的成员。
简单一句话：对于成员变量无论是编译还是运行都参考引用型变量所属类中的成员变量。
也就是说：成员变量看等号左边。
2、 成员函数：
当子父类中出现一模一样的函数时，在多态调用中的特点：
在编译时：参考引用型变量的所属的类中是否有调用的成员函数。
在运行时：参考的是对象所属的类中是否有调用的成员函数。
原因是：编译时期应该参考父类，运行时期应该参考子类。因为成员函数上有一个特点覆盖。
简单一句话：对于成员函数，编译看左边，运行看右边。
3、 静态函数：
在编译时期：参考引用型变量所属的类中是否调用的静态函数，如果有编译经过，如果没有编译失败。
在运行时期：参考的还是引用型变量所属的类中的静态函数。
简单一句话：对于静态函数，无论是编译还是运行都看左边
总结：对于多态成员而言，无论编译还是运行都看左边，只有成员非静态函数，编译看左边，运行看右边，因为覆盖的特性。

2、 多态的应用：
代码实现：
Object：所有类的父类该类中的方法所有对象都具备。
代码实现：
Class Demo extends Object
{
Private int num;
Demo(int num)
{
This.num=num;
}
一般都会按照对象自身的特点对对象进行比较，比如：现在要比较两个Demo对象中null值是否相同。
}
Public boolean compare(Demo b)
{
Return this.num=d.num;
}
发现Demo继承Oject已经具备了比较对象的方法，因此没有必要再定义新的方法compare了，直接使用equals就能够了，可是Object equals比较的是地址值，不是我们所需的，那就保留的父类的功能声明，建立自身的比较内容，这就是覆盖。
Public boolean equals(Object obj)
{
If(!(Object instanceof Deno))
Return false;
Demo d=(Demo)obj;向下转型。
Return this.num=d.num;此处体现了多态的特性。
}
Public String toString()
{
Return "demo:"+num;
}
Class ObjectDemo
{
Public static void main(String[] args)
{
Demo d1=new Demo(4);
Demo d2=new Demo(4);
Sop(d1.toString());
Sop(d1);
Sop(c1.getName());
Sop(pare(d2));

}
}

4、 内部类：
将一个类定义在另外一个类的里面的类称为内部类
当一个类要直接访问另外一个类的成员时，能够将这个类定义到另一个类里面，称为另一个类的内部类。
内部类访问的规则：
1、 内部类能够直接访问外部类中的成员。
2、 外部类需要创立内部类对象才能够访问内部类中的成员。
在描述事物时，事物中还有具体的事物时，而且这个内部事物在访问着外部的事物时。
这时对这个内部事物的描述，就能够用内部类完成。

内部类出于外部类的成员位置上是能够被成员修饰符所修饰的。
Public
Private：将内部类私有化时，只能对外提供方法，对内部类的控制。
Static：当内部类中定义了静态的成员时，该内部类必须静态的，否则编译失败。
代码体现：
Class Outer
{
Static int num=4;
Static class Inner
//内部类，为什么要定义内部类？
当一个类要直接访问另一个类中的成员时。能够将这个类定义到另一类里面。
{
Static void show()
{
Sop("show run"+num);
}
Public void method()
{
Inner in=new Inner();
In.,show();
}
}
}
Class InnerClassDemo
{
Public static void main(String[] args)
{
//Outer out=new Outer();
//out.method();
//System.out.println("Hello World!");
//当访问一个外部类的内部类时，先由外部类对象再有内部类对象。
//Outer.Inner in=new Outer().new Inner();//要指明内部类所处的外部类
//in.show();

//内部类静态化，要调用的非静态的方法show();
//Outer.Inner in=new Outer.Inner();
//in.show();

//如果show方法也是静态的，要调用静态的方法show();
Outer.Inner.show();
}
}

5、 匿名内部类：没名字的内部类。
就是内部类的简化写法。
前提：内部类能够继承或者实现一个外部类。
代码实现：
格式：
New 父类名or 接口名(){子类的具体内容}
Abstract class AbdsDemo
{
Abstract void show1();
Abstract void show2();
}
Class Outer
{
Int num=4;
New AbsDemo()
{
Void show()//匿名内部类
{
Sop("num==="+num);
}
}.show();
}
Public void method2()
{
AbsDemo a=new AbsDemo();
{
Public void show1();
Public void show2()
};
A. show1();
A. show2();
//要想调用两个方法，怎么做？起个名称即可
当里面有多个方法的时候建议不要写匿名内部类。
}

-------------------------------------------------------------------------------------------
interface Inter
{

void show();
}
class Outer
{
//补足代码。最好用匿名内部类
static Inter method()//为什么是Inter类型
{

return new Inter()
{
public void show()
{
System.out.println("show run");
}
};
}
}

class InnerClassTest
{
public static void main(String[] args)
{
Outer.method().show();
/*
Outer.method():Outer类中有一个method方法，而且这个方法是静态的。
Outer.method().show

会返回一个对象，而且这个对象还能够调用show方法
说明这个对象肯定是Inter类型。
*/
}
}

--------------------------------------------------------------------------------------------
6、 异常：
是在运行时期发生的不正常情况
Java发现不正常的情况都包含着一些常见信息，并 将这些信息进行了对象的封装。
异常这种机制，其实就是java按照面向对象的思想将出现的问题封装成了对象。
在进行问题分析时，发现问题有很多种，可是不断向上抽取，最终问题能够归纳为两种，一种是能够针对处理的一种是一般不进行处理的。

在java中的体现一个是Exception ,一个是Error,后者一般针对处理。

无论是异常还是错误，她们都有名称信息等共性的内容。

能够继续抽取形成一个父类：throwable可抛出。
Throwable
|---Error
|---Exception
异常和错误都有一个特点：其子类的名称的后缀名都是父类名。

该体系具备一个特殊的特性叫做可抛性，该体系中的类能够被关键字throws抛出。
该体系中的类产生的对象能够被Throw抛出，简单说该体系能够被Throws 和throw操作。

Throw 和throws的区别：
Throws：定义在函数上，用于声明函数的可能出现的问题，后面跟异常类，能够跟多个，用逗号隔开、
Throw:定义在函数内，用于抛出异常对象因为程序的跳转，后面跟的是异常对象。

If判断和异常处理的区别：
If判断是将正常代码和异常代码写在一起。阅读性极差，异常处理将问题代码和异常处理代码分离。
代码实现：
Class Demo
{
功能的定义着在定义工呢过时，发现该功能容易因为未知内容的不确定性的出现的问题。为了让调用者明确，有可能有问题，需要在函数上对问题进行声明。
需要一关键字throw异常名。
Int div（int a,int b）throws Exception//抛出异常是为声明异常问题，让调用者去处理。
{
If(b==0)
Throw new ArithmeticException("除数为零、违反规则");
Return a/b;
}
}
对异常的针对性处理方式：
Try
{
需要被检测的代码；
}
Cathch（异常类 变量）
{
异常处理代码
}
Finaly
{
一定会被执行的代码。
}

自定义异常：
Java将常见的问题都封装成了对象。
对于自定义项目中出现的问题，java并未给出对应的描述，这时我们就需要按照面向对象的思想自己完成对问题的描述和封装。
自定义异常：
需求：在我的程序中，进行除法运算，除数不能够为负数也不能够为0;
对0这种情况，java中有对应的描述，ArithmeticException
对于负数，java中没有。只有我们自己定义，定义一个类来对异常进行描述。

Class FuShuException extends Exception
{
Private int num;
FuShuException(){}
FuShuException(String message,int num)
{
Super(message);
This.,num=num;
}
Public int getNum()
{
Return num;
}
}
Class Demo
{
Int div(int a,int b)throws FuShuException
{
If(b<0)
Throw new FuShuException("除数不能够为负数");
函数内抛出异常，函数上一定要标示。
函数内抛出是什么？函数上就标示什么？
对方抛出什么异常，我就处理什么异常。
Return a/b;
}
}

Class ExceptionDemo2
{
Public static void main(String[] aths)
{
Demo d=new Demo()；
Try
{
Int num=d.div(4,-1);
Sop("num="+num);
}
Cathc(FuShuException e)
{
Sop();
e.printStackTrace();
}
Sop("over");
}
}

自定义应用：
异常分两种：
1、编译被检测的异常：Exception
这种异常一般都需要进行针对性的处理。
2、运行时发生的异常：RuntimeException
对于运行时异常一般是不编写针对性的处理方式，如果该异常发生就让程序停止，
对程序进行修正。因为这种的出现往往已经无法让程序继续运算了。
class Demo
{
int div(int a,int b)throws ArithmeticException
{
if(b==0)
throw new ArithmeticException("除数为零");
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
getIndex(null,4);
}
public static int getIndex(int[] arr,int key)
{
if(arr==null)//进行健壮性判断。
throw new NullPointerException("没有具体的数组");
for(int x=0;xnterException("没有具体的数组实例");
if(index<0||index>=arr.length)
throw new ArrayIndexOutOfBoundsException("角标越界");
return arr[index];
}
}
----------------------------------------------------------------------------------------------------------------
异常练习：
/*
需求：
毕老师用电脑上课。按照面向对象思想来描述。名词提炼法
上课过程中出现的问题：
1、电脑蓝屏了。
2、电脑冒烟了。
*/
class LanPinException extends Exception
{
LanPinException(String message)
{
super(message);
}
}
class MaoYanException extends Exception
{
MaoYanException(String message)
{
super(message);
}

}
class NoPlanException extends Exception
{
NoPlanException(String message)
{
super(message);
}
}
class Computer
{
private int state=2;
public void run()throws LanPinException,MaoYanException
{
if(state==1)
throw new LanPinException("电脑蓝屏了");
if(state==2)
throw new MaoYanException("电脑冒烟了");
System.out.println("电脑运行");
}
public void reset()
{
System.out.println("电脑重启");
state=0;
}
}
class Teacher
{
private String name;
private Computer cmpt;
Teacher(String name)
{
cmpt=new Computer();
this.name=name;
}
public void prelect()throws NoPlanException//此处冒烟是电脑发生的，能再老师讲课的功能出现这样的异常么？因此抛出的对象不对，老师只能耽误了讲课的进度，因此此时是否应该定义一个关于讲课进度的类来封装这个问题。
{
try
{
cmpt.run();
System.out.println(name+"毕老师讲课");
}
catch (LanPinException e)
{
System.out.println(e.getMessage());
cmpt.reset();
prelect();
}
catch (MaoYanException e)//这个功能我处理不了，因为冒烟不会了，这时候需要抛出。
{
test();
//throw e;//因为处理不了，继续往外抛。此时在讲课方法上要声明。此处也不能抛出这个异常。因为冒烟是电脑运行时的，不是老师讲课的。
throw new NoPlanException("课时无法继续进行");

}
}
public void test()
{
System.out.println("练习");
}
}
class ExceptionTest
{
public static void main(String[] args)
{
Teacher t=new Teacher("毕老师");
try
{
t.prelect();

}
catch (NoPlanException e)
{
System.out.println("换人");
}

}
}
//到底什么是抛什么处理？
/*
自己能解决的就处理，处理不了就抛。
比如着火了，小火的时候自己能够处理，比如灭火器等
当火势大了，就处理不了，只能交给消防队，自己要跑。
*/