疯狂java讲义笔记2：面向对象的基础

疯狂java讲义笔记2：

面向对象的基础

面向接口编程


接口体现的是一种规范和实现相分离的设计哲学


简单工厂模式：
Computer类需要组合一个输出设备，让computer类组合一个output类型的对象，将computer与具体的输出接口printer完全分离，方便大量的类重用这个printer和修改他


public class Computer
{
private Output out;
public Computer(Output out)
{this.out=out;}


public void keyIn(String msg)
{
out.getData(msg); //利用Output的对象来实现
}


public void print() //定义一个打印的方法
{
out.out(); //利用Output的对象来实现
}


}


public class OutputFactory
{
public  Output getOutput()
{
return new Printer();
}

}


public interface Output{...}


public class printer implements Output{...}


使用：
...
OutputFactory of=new OutputFactory();
Computer c=new Computer(of.getOutput()); //利用of.getOutput()生成一个printer对象，传给Computer
//Computer的形参是Output型，但是实参是printer型，则多态了，printer的方法，Output的Field
c.keyIn("少时诵诗书");
c.print();




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


命令模式
场景：某个方法需要完成某个行为，但是这个行为的具体实现无法确定，必须等到执行该方法时才可以确定
我们要将“处理行为”作为一个参数传入方法


public interface Command
{
void  process(int[] target);
}


public class ProcessArray
{
public void process(int[] target,Command cmd)
{
cmd.process(target); //使用
}
}


public interface Command
{...}


public PrinterCommand implements Command //一种命令
{...}


public AddCommand implements Command //另一种命令
{...}


使用：
ProcessArray pa=new ProcessArray();
int[] target={...};
pa.process(taget,new PrinterCommand()); //把对象传入
pa.process(taget,new AddCommand());




内部类提供更好的封装，可以把内部类隐藏，无法使用
在外部类中使用非静态类时，和平时使用类没有区别
在内部类中可以直接访问外部类的private成员
外部类不可以直接访问内部类的非静态Field要加类名或是利用setter或getter
不允许在非静态的内部类中定义静态成员
如果用static修饰一个内部类，这个类就属于外部类本身。而外部类的上层是包，不可以使用static修饰外部类（静态类都是内部类）
静态内部类不可以使用外部类的实例成员，只能访问类（静态）成员
内部类的使用
1、在外部类内，和正常使用无区别
2、在外部了外使用非静态内部类，Outer.Inner i=new Outer().new Inner();//后面那个new调用内部类的构造器
创建非静态内部类之前，必须要先建立一个外部类对象
3、在外部类外使用静态内部类
创建静态内部类之前，无须要先建立一个外部类对象，Outer.Inner i=new Outer.Inner();


在方法中的内部类是局部内部类，其作用域只在方法中


匿名内部类
适合只使用一次的类
interface Product
{抽象的方法}


public 某类{
public void test(Product P){
...
}


public static void main(String[] args)
{
某类 i=new 某类();
i.test(new Product(){具体的方法})
}
}
继承接口的匿名类中不能有显示的构造器，只能有默认的无参数构造器。
但是继承一个正常父类的匿名类，会有一个同父类形参的构造器。
... class Product(){
...有参数的和无参数的构造器...
}
public class main所在类
{
i.test(new Product(...){具体的方法}) //有参数


Product d=new product() //无参数
{...具体的方法...}
i.test(d);
}
匿名内部类需要访问外部类的局部变量，需要用final修饰这个局部变量




闭包：内部可以访问外部信息（或保存），并返回内部类型引用出来
回调
interface T
{
...work();...
}
public class P
{
...work(){...}...
}
public  class TP extends P implements T
{
如何把上面的两个work都可以使用？
}
public class TP extends P
{
...
private class closure implemens T
{
...work(){}... //T接口work方法的具体
}
public TPgetback()
{
return new closure(); //返回内部类型引用出来
}
}
使用：
TP tp=new TP;
tp.work(); //这个方法来自于P
tp.TPgetback().work(); //这个方法来自于T


枚举类
public enum GenderEnum
{
//在这当中要使得在生成其对象时，不可变而且有限。
}
实例：
public enum GenderEnum
{
MALE("男"),FEMALE("女"); //枚举值
private final String name;
//构造器
private GenderEnum(String name) //列出前面的枚举值时,其实就是在调用构造器创建枚举类对象
{
this.name=name;
}
public String getName()
{
return thid.name;
}
}
实现接口的枚举类
public interface GenderDesc
{
void info(); //对枚举类来说，一般默认都是final修饰，但是如果有了抽象方法，就默认用abstract修饰
//可以派生子类
}
public enum Gender implements GenderDesc
{
MALE("男")
{info的具体方法}
FEMALE("女")
{info的具体方法}
}




对象与垃圾回收（只回收堆内存的对象）
对象在堆内存中有三种状态
1、可达，有引用指向它
2、可恢复，没有引用指向它，准备被回收
3、不可达状态，系统已经调用过了一次finalize()方法
强制垃圾回收（其实是通知系统来做回收，但系统JDK会不会回收不一定）
System.gc();
Runtime.getRuntime().gc();
  finalize()方法（当这个方法返回后才开始）
这个类似于析构函数（垃圾回收开始前可以显示通知一类的），但是在System.gc();之后不一定会执行