Java面向对象（接口、匿名内部类、object类、单例、多例）

1.1接口（抽象类与接口，优先使用接口）

抽象方法和全局常量的集合，使用interface定义，使用implements继承

接口可以多继承（可以向上强制转换）

接口只能有public，一般不写常量

接口可以定义一系列的内部接口，包括：内部的普通类、内部抽象类、内部接口，其中使用 static

定义的内部接口就相当于是一个外部接口。

interface IMessage{
	public static final String MSG = "JK";
	public abstract void print();
}
interface INew{
	public abstract String get();
}
// 接口继承接口只能用extends
interface C extends IMessage,INew{
	public abstract void printC();
}
// 抽象类可以继承接口
abstract class AbstractMessage implements INew{
	public abstract void printMessage();
}
// 一个类可以实现多个接口
class MessageImpl extends AbstractMessage implements IMessage,INew{
	public void print(){}
	public String get(){
		return IMessage.MSG;
	}
	public void printMessage(){
		System.out.println("cxl");
	}
}
class CImpl implements C{
	public void print() {
	}
	public String get() {
		return IMessage.MSG;
	}
	public void printC() {
		System.out.println("printC");
	}
}
public class JkDemo {
	public static void main(String[] args) {
		MessageImpl mg = new MessageImpl();
		INew news = (INew)mg; // 可以向上转换
		System.out.println(news.get());
		AbstractMessage am = (AbstractMessage)mg;
		am.printMessage();
		CImpl c = new CImpl();
		c.printC();
	}
}

接口的定义与使用

定义操作标准

表示能力

在分布式开发之中暴露远程服务方法

1.2工厂设计模式（解耦合、提升代码复用程度）

interface IFruit{
	public abstract void eat();
}
// 使用factory可以解耦合
class Factory{
	public static IFruit getInstance(String className){
		if ("apple".equals(className)) {
			return new apple() ;
		}
		if ("orange".equals(className)) {
			return new orange() ;
		}
		return null ;
	}
}
class apple implements IFruit{
	public void eat(){
		System.out.println("直接吃苹果！");
	}
}
class orange implements IFruit{
	public void eat(){
		System.out.println("剥皮吃橘子！");
	}
}
public class FactoryDemo {
	public static void main(String[] args) {
		IFruit fruit = Factory.getInstance ("apple") ;
        fruit.eat();
		fruit = Factory.getInstance ("orange") ;
        fruit.eat();
	}
}

1.3代理设计模式（Proxy）

代理的本质：每笔真实业务操作都有一个与之辅助的功能类功能完成

interface ISubject{
	public void save();
}
class RealSubject implements ISubject{
	public void save(){
		System.out.println("救人！");
	}
}
// 代理实现
class ProxySubject implements ISubject{
	private ISubject subject; // 真正的操作者
	public ProxySubject(ISubject subject){
		this.subject = subject;
	}
	public void broke(){
		System.out.println("代理：破门！");
	}
	public void get(){
		System.out.println("代理：获奖!");
	}
	public void save(){
		this.broke();
		subject.save();
		this.get();
	}
}
class FactorySubject{
	public static ISubject getInstance(){
		return new ProxySubject(new RealSubject());
	}
}

public class ProxyDemo {
	public static void main(String[] args) {
		ISubject sub = FactorySubject.getInstance();
		sub.save();
	}
}

接口是Java的核心，慢慢需要学习到接口更多的使用以及设计

开发之中优先考虑接口，以避免单继承局限。

No	区别点	抽象类	接口
1	关键字	abstract class类名称{}	interface接口名称}
2	结构组成	抽象方法、普通方法、全局常量、全局变量、属性、构造方法	抽象方法和全局常量
3	权限	可以使用各种权限	只能够使用public访问权限
4	子类使用	子类利用extends关键字来继承抽象类	子类利用implements关键字来实现接口
5	关系	一个抽象类可以实现若干个接口	一个接口不能够继承抽象类，但是可以使用extends来继承多个父接口
6	子类限制	一个子类只能够继承一个抽象类	一个子类可以实现多个接口

匿名内部类

由于接口、抽象类不能实例化，所以在new时直接跟大括号里面写方法

普通类也可以这么写，但这不规范

object类

所有的类都继承自object，他是最高统一类型

直接输出类是地址，可以覆写

字符串是王道

object可以接收所有的引用类型

包装类

包装类值得是将基本数据类型封装在一个类。

将基本数据类型封装在一个类对象的本质就在于方便使用Object进行接收处理

对象型：Character、Boolean

数值型：Byte、Short、Long、Float、Double、Integer

装箱与拆箱

== 是地址  equals是比较值

主要指的就是使用包装类定义变量、获取变量

包的定义与使用

如果两个类同名，那么定义它们的时候要用全名

访问控制权限

private、default、protected、public

jar包

将生成的程序类打包为jar文件：jar -cvf my.jar cn

SET CLASSPATH=.;d:\mypack\my.jar

单例设计模式

一个类只能产生一个实例化对象

类中没有构造方法，则会自动生成一个无参的构造方法，但有构造方法的时候，不会生成

只会产生一个对象

饿汉式：只要加载了，一定会创建一个公共的instance对象，追加final

懒汉式：只有调用的时候，才会加载，可能会有性能问题

class Singleton {
	private final static Singleton instance = new Singleton() ;  //饿汉式
//	private static Singleton instance = null ; //懒汉式
	public static Singleton getInstance(){
//		if(instance == null){
//			instance = new Singleton();
//		}
		return instance;
	}
	private Singleton() {
		
	}
	public void print() {
		System.out.println("Hello world ! ");
	}
}
public class Dl {
	public static void main(String[] args) {
		Singleton s = null;
		s = Singleton.getInstance();
		s.print();
	}
}

多例

所谓的多例只是比单例追加了更多个内部实例化对象的产生。

单例、多例构造方法必须私有化

构造方法私有化

类内部一定会有一个static方法用于取得类的实例化对象。多例设计模式已经被枚举所取代了。