面向对象2(2)

面向对象2(2)
一、知识点：
1.接口
2.多态
3.内部类
二、接口：
1.当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
接口 interface来代替。
2.接口中的成员修饰符是固定的（只能有这个两种元素）
3.接口的出现将“多继承”通过另一种形式体现出
来，即“多实现”。


三、接口的特点：
1.接口是对外暴露的规则。


2.接口是程序的功能扩展，可以用来多实现。
3.类与接口之间是实现关系，而且类可以
继承一个类的同时实现多个接口。


4.
接口与接口之间可以有继承关系，


类可以同时继承抽象类和接口。
四、多态：
1.某一类事物的多种存在形态。
2.猫这个对象对应的类型是猫类型
，同时猫也是动物中的一种，也可以把猫称为
动物。


3.动物是猫和狗具体事物中抽取出来的父类型。


4.对象的向上转型
对象的向下转型（向下转型必须先要向上转型）。
5.父类或者接口的引用指向或者接收自己的子类对象。


6.多态的存在提高了程序的扩展性和后期可维护性
。
7.需要存在继承或者实现关系要有覆盖操作。
五、多态的特点：
1.编译时：要查看引用变量所属的类中是否有所调用的成员。
2.在运行时：要查看对象所属的类中是否有所调
用的成员。
3.只看引用变量所属的类。
4.在多态中进行向下转型最好是先用instanceof判断下类型
。
六、类设计的注意事项：
1.类的设计主要是父类的设计
。
2.子类永远不要去 继承一个已经完全实现好了的类，因为一旦发生向上转型，
   所调用的方法一定是被子类覆盖过的方法，所以只会继承抽象类或者是接口。
七、抽象类和接口的区别：
1.抽象类是一个模板
，而接口是一个标准


。
八、工厂设计模式Factory：
代码：
class Factory//工厂类
{
public static Fruit get(String name)
{
Fruit f = null;
if("苹果".equals(name))
{
f = new Apple();
}
if("橘子".equals(name))
{
f = new Orange();
}
return f;
}
}
九、代理类设计模式Proxy：
代码：
class ProxyCl implements Net
{
private Net net;
public ProxyCl(Net net)
{
this.net = net;
}

public boolean check()
{
boolean inf = true;
return inf;
}


public void browse()
{
this.check();
this.net.browse();
}
}
十、内部类：
1.将一个类定义在另一个类的里面，对里面那个
类就称为内部类（内置类，嵌套类）。
2.内部类可以直接访问外部类中的成员，包括私有成
员。


3.而外部类要访问内部类中的成员必须要建立内部类
的对象。


代码：
class  InnerDemo
{
public static void main(String[] args) 
{
new Outer().getInner().print();
}
}


class Outer
{
private String name = "haoren";
class Inner
{
public void print(){
System.out.println(name);
}
}
public Inner getInner(){
Inner in =  new Inner();
return in;
}
}
在外部访问内部类：
Outer outer = new Outer();


Outer.Inner in = outer.new Inner();

in.print();


十一、使用static定义内部类：
代码：
class  InnerDemo
{
public static void main(String[] args) 
{
//new Outer().getInner().print();
new Outer.Inner().print();
}
}


class Outer
{
private static String name = "haoren";
static class Inner
{
public void print(){
System.out.println(name);
}
}
}
十二、匿名内部类：
1.就是内部类的简化写法。


2.内部类可以继承或实现一个外部类或者接口。
3.就是建立一个建立一个带内容的外部类或者接口的子类
匿名对象。


代码：
class NoNameDemo 
{
public static void main(String[] args) 
{
Do d = new Do();
//d.print(new B());
d.print(new A(){public void test(){
System.out.println("haha");
}});
}
}
interface A
{
void test();
}
class B implements A
{
public void test(){
System.out.println("hahah");
}
}
class Do
{
public void print(A a){
a.test();
}


}