1.多态：可以理解为事物存在的多种体现形态
a.多态的体现
父类的引用指向了自己子类对象
即父类的引用也可以接收自己的子类的对象
b.多态的前提
必须是类与类之间有关系，要么是继承，要么是实现
通常还有一个前提：存在覆盖
c.多态的好处
大大的提高了程序的扩展性
d.多态的应用
e.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员
2. instanceof 判断所属类型
3.
class DuoTaiDemo
{
public static void main(String[] args)
{
Fu f = new Zi();
f.method1();
//f.method3();
/*
在多态中成员函数的特点：
在编译时期：参阅引用类型所属的类中是否有调用方法，
如果有f.method1();编译通过，没有的话编译失败f.method3();
在运行时期：参阅对象所属的类型中是否有调用方法
简单总结：成员函数在多态调用时，编译看左边，运行看右边
*/
Fu f = new Zi();
System.out.println(f.num);//结果是fu类中的num :5
/*
在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）。
在多态中，静态成员函数的特点：
无论编译和运行，都参考左边
*/
}
}
class Fu
{
int num = 5;
public void method1()
{
System.out.println("method_fu_1");
}
public void method2()
{
System.out.println("method_fu_2");
}
}
class Zi extends Fu
{
int num = 8;
public void method1()
{
System.out.println("method_zi_1");
}
public void method3()
{
System.out.println("method_zi_3");
}
}
4.
/*
接口和多态实现了程序的扩展性
*/
class DuoTaiDemo1
{
public static void main(String[] args)
{
MainBoarde mb = new MainBoarde();
mb.run();
mb.runPCI(new NetCard());
}
}
interface PCI
{
public abstract void open();
public abstract void close();
}
class MainBoarde
{
public void run()
{
System.out.println("mainboard run") ;
}
public void runPCI(PCI p)
{
if(p != null) {
p.open();
p.close();
}
}
}
class NetCard implements PCI
{
public void open(){
System.out.println("NetCard open");
}
public void close(){
System.out.println("NetCard close");
}
}
5.
/*
object 重写equals方法
*/
class MyPerson
{
private int num = 0;
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return this.num;
}
//重写equals方法
public boolean equals(Object obj)
{
//判断是否是MyPerson类型
if(!(obj instanceof MyPerson))
return false;
//强制转为MyPerson类型
MyPerson p = (MyPerson)obj;
this.num = p.num;
return true;
}
}
class ObjectTest
{
public static void main(String[] args)
{
MyPerson p1 = new MyPerson();
p1.setNum(2);
MyPerson p2 = new MyPerson();
p2.setNum(2);
System.out.println(p1.equals(p2));
System.out.println(p1 == p2);
}
}
6.类不能被private修饰，内部类可以被private修饰
7.局部内部类中的成员函数不能被static修饰
8.
/*
内部类定义在局部时
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类中的引用
但是不可以访问它所在的局部中的变量，只能访问final修饰的局部变量
*/
class Outer
{
int x = 1;
void function(final int a)
{
final int y =5;
class Inner //内部类
{
void function()
{
System.out.println("innner:"+y);//只有将y定义成final类型才能访问
System.out.println("innner:"+a);//只有将a定义成final类型才能访问
}
}
}
public void method()
{
Inner in = new Inner();
in.function();
}
}
9.匿名内部类：
a.匿名内部类其实就是内部类的简写格式
b.定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口
c.匿名内部类的格式： new 父类或者接口(){定义子类的内容}
d.其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象。
e.匿名内部类中定义的方法最好不要超过3个
10.
/*
匿名类使用的一个示例
*/
interface Inner
{
public abstract void method();
}
class Test
{
public static Inner function()
{
Inner in = new Inner()
{
public void method()
{
System.out.println("run method");
}
};
return in;
}
}
class InnerClassTest
{
public static void main(String[] args)
{
Test.function().method();
}
}
11.异常：就是程序在运行时出现不正常情况
异常由来：问题也是现实生活中的一个具体的事务，也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对问题的划分：一种是严重的问题；一种是非严重的问题
对严重的问题：java通过error类进行描述
对于Error一般不编写针对性的代码进行处理
对于非严重的问题：java通过exception类进行描述
对于Exception可以使用针对性的处理方式处理
Throwable
---Error
---Exception
12.捕捉异常的一个例子
class ExceptionDemo
{
public static void main(String[] args)
{
int a = 4,b = 0;
try {
int c = a/b;
} catch (Exception e) {
System.out.println("除数不能为0");
System.out.println(e.getMessage());
System.out.println(e);//异常名称：异常信息
e.printStackTrace() ;//异常名称：异常信息：异常位置
}
System.out.println("over");
}
}
13. 如何为自定义异常？
因为父类已经把异常信息的操作都完成了
那么就可以直接通过getMessage方法获取
自定义异常：必须是自定义类继承Exception
继承Exception原因：
异常体系有一个特点：异常类和异常对象都被抛出
他们都具备可抛性，这个可抛性是Throwable这个体系中独有的特点
只有这个体系中的类和对象才可以被throws和throw操作
//自定义一个异常类
class FuShuException extends Exception
{
private int value = 0;
FuShuException()
{
super();
}
FuShuException(String message,int value)
{
//父类Exception中构造函数Exception(String message)
super(message);
this.value = value;
}
public int getValue()
{
return value;
}
}
class Div
{
public int div(int a,int b) throws FuShuException
{
if(b<0)
throw new FuShuException("除数不能为负数",b); //抛出可能的异常
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Div d = new Div();
//捕获可能出现的异常
try {
d.div(5,-1);
} catch (FuShuException e) {
System.out.println(e.getMessage());
System.out.println("被除数是"+e.getValue());
}
System.out.println("over");
}
14.throws:使用在函数上。 后面跟异常类，可以跟多个，用逗号隔开
throw使用在函数内 后面跟的是异常对象
}
15
/*
内部类的访问规则：
1.内部类可以直接访问外部类的成员，包括私有
之所有可以直接访问外部类中的成员，是因为内部类中持有了外部类的引用，格式：外部类名.this
2.外部类要访问内部类，必须建立内部类对象
访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类的对象。
格式：外部类.内部类 变量名 = new 外部类.new 内部类
Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上，就可以被成员修饰符所修饰
比如：private 将内部类在外部类中进行封装
static 内部类具备static的特性
当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
在外部其他类中，如何直接访问static内部类中的非静态成员呢？
new Outer.Inner().function();
在外部其他类中，如何直接访问static内部类中的静态成员呢？
Outer.Inner.function();
注意：当内部类中定义了static成员，内部类也必须定义成static
当外部类的static方法要访问内部类函数时，内部类也必须定义成static
*/
class Outer
{
int x = 1;
class Inner //内部类
{
int x = 2;
void function()
{
int x = 3;
System.out.println("innner:"+x);//打印结果是3
System.out.println("innner:"+this.x);//打印结果是2
System.out.println("innner:"+Outer.this.x);//打印结果是1
}
}
public void method()
{
Inner in = new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
//直接访问内部类中的成员
Outer.Inner in = new Outer().new Inner();
in.function();
}
}