好吧.今天下午又写一篇吧.
1. 几个代码块:
class Demo2 {
{// 构造快
System.out.println("*********构造快**********");
}
static {
System.out.println("***********类中的静态块**********");
}
public Demo2() {// 构造方法快
System.out.println("*********构造方法***********");
}
};
public class DemoTest {
static {
System.out.println("*********主类中的静态块******");
}
public static void main(String args[]) {
new Demo2();
new Demo2();
new Demo2();
}
}
结果: *********主类中的静态块******
***********类中的静态块**********
*********构造快**********
*********构造方法***********
*********构造快**********
*********构造方法***********
*********构造快**********
*********构造方法***********
2. 几个关键字:
a) this关键字:
i. 可以表示当前对象;
ii. 通过this.属性表示当前类中的属性;
iii. 通过this.方法()表示当前类中的方法
iv. 通过this()可以调用本类中的其它构造方法,但是要求至少有一个构造方法没有使用this(),
而且调用时this()要放在构造方法的首行b) super关键字:
i. super.属性,表示直接找到父类中的属性
ii. super.方法(),表示直接找到父类中被子类覆写过的方法
iii. 通过super()从子类调用父类中的构造方法,子类不管如何编写代码,肯定先要调用父类的构造
c) 关键字:
i. 使用static关键字可以声明全局变量,所以对象共同使用
ii. static属性或方法可以直接通过类名称调用
iii. static方法只能带哦用static属性,而不能调用非static的属性或方法
d) final关键字:
i. 声明类,声明的类不能有子类
ii. 声明方法:声明的方法不能被子类所覆盖
iii. 声明变量:声明的变量就成为了常量
3. 几个类:
a) 内部类:在一个类的内部还有另外的一个类,称为内部类
i. 内部类的唯一优点:在于可以方便的访问外部类中的私有成员
ii. 如果在外部直接使用内部类的实例化对象:外部类.内部类 内部类对象=外部类实例.new 内部类实例()
iii. 一个内部类如果使用static关键字声明的话,则此内部类就将成为外部类,直接可以通过外部类.内部类的形式访问
iv. 在方法中定义的内部类,可以直接访问外部类中的各个成员,但是如果访问方法中的参数,则在参数上要使用final关键字声明;
b) 抽象类和接口的区别:
c) 匿名类: "hello". toUpperCase()这就是一个匿名类调用了一个方法的 过程.下面这个代码是多线程中的.其中就有一个匿名内部类
public class temp2 { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("hello: " + i); } } }); t1.start(); } }
d) 包装类:i. 数值型:Integer、Byte、Float、Double、Long(6个都是Number的子类)
ii. 其他类型:Chracter、Boolean
e) Object类:
i. 超类,所有类的父类,注意它的常用的几个方法:
public boolean equals (Object obj)
public int hashCode ()
public String toString()
4. 几个模式:
单例模式:使用private关键字对构造方法私有化.则外部无法实例化,然后再在内部声明一个static此类的一个的实例.
class Single {
private static Single instance = new Single();
private Single() {
// 将构造方法私有化
}
public static Single getInstance() {
return instance;
}
};
public class SingleDemo {
public static void main(String[] args) {
Single s1 = null;// 声明对象
s1 = Single.getInstance();// 实例化对象
Single s2 = Single.getInstance();
System.out.println(s1==s2);
}
}
工厂模式: 工厂模式专门负责将大量有共同接口的类实例化① 简单工厂模式(Simple Factory) 又叫静态工厂模式:
interface Fruit { public void eat(); } class Apple implements Fruit { @Override public void eat() { System.out.println("吃苹果..."); } }; class Orange implements Fruit { @Override public void eat() { System.out.println("吃橘子..."); } }; class Factory {// 工厂类 public static Fruit getFruit(String className) { Fruit f = null; if ("apple".equals(className)) { f = new Apple(); } if ("orange".equalsIgnoreCase(className)) { f = new Orange(); } return f; } } public class InterDemo { public static void main(String[] args) { Fruit f = Factory.getFruit(args[0]); if (f != null) { f.eat(); } } }
② 工厂方法(Factory Method):a) 不贴代码了.偷偷懒这里讲简单工厂、工厂方法讲的很好.http://www.cnblogs.com/zzj-46000452/archive/2006/09/16/506286.html
③ 抽象工厂(Abstract Factory):
a) 有点晕乎了.改天再去看看.
代理模式:
① 静态代理:
interface HelloWorld { public void print(); }; class HelloWorldImpl implements HelloWorld { @Override public void print() { System.out.println("helloworld(这个是真实对象具体动作)"); } }; class StaticProxy implements HelloWorld { public HelloWorld helloWorld;// 这里用引用.进行组合 public StaticProxy(HelloWorld helloWorld) {//创建代理对象的时候同时创建一个真实对象类 this.helloWorld = helloWorld; } public void print() { System.out.println("welcome(这个是应用静态代理产生的附加动作)"); helloWorld.print(); } } public class TestStaticProxy { public static void main(String[] args) { HelloWorld helloWorld = new HelloWorldImpl(); StaticProxy staticProxy = new StaticProxy(helloWorld); staticProxy.print(); } }
② 动态代理:import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; //抽象角色 interface UserManager { public void addUser(String username, String password); public void deleteUser(String id); } // 然后写这个接口的实现类: class UserManagerImpl implements UserManager { @Override public void addUser(String username, String password) { System.out.println("增加的用户名:" + username + " 密码:" + password); } @Override public void deleteUser(String id) { System.out.println("删除用户"); } } // 代理类 class DynamicProxy implements InvocationHandler { private Object targetObject;// 表示代理实例 // 返回一个代理实例 public Object newProxy(Object targetObject) { this.targetObject = targetObject;//初始化代理对象成功 /*Proxy类中public static Object newProxyInstance(ClassLoader loader, Class<?>[] interface, InvocationHander h)*/ return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this); } //Object invoke(Object proxy, Method method, Object[] args) //在代理实例上处理方法调用并返回结果。 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { doSomething1();//真实方法前执行的一些方法 method.invoke(targetObject, args);//这个方法必须要写,否则就无法实现代理,表示调用代理类的方法 doSomething2();//真实方法前执行的一些方法 return null; } //代理中添加的操作.比如日志,权限检查等操作.静态代理也会有这样的操作,这也是AOP(面向切面编程)的基本原理 public void doSomething1(){ System.out.println("---------------检查权限--------------"); } public void doSomething2(){ System.out.println("---------------书写日志--------------"); } } public class Client { public static void main(String args[]){ DynamicProxy handler = new DynamicProxy();//代理类的一个实例 UserManager manager = (UserManager)handler.newProxy(new UserManagerImpl());//实例化真实对象, //将真实对象和代理绑定,真实对象就会自动调用invoke() manager.addUser("yonghuming", "mima");//执行自己的方法之前就进行了拦截,实现打印语句 manager.deleteUser("110"); } }
适配器模式:
interface Window{ public void open();//打开窗口 public void close();//关闭窗口 public void icon();//最小化 public void unicon();//最大化 } abstract class WindowsAdapter implements Window{ @Override public void close() { } @Override public void icon() { } @Override public void open() { } @Override public void unicon() { } }; class MyWindow extends WindowsAdapter{ public void open(){ System.out.println("打开窗口!");//哈哈.因为不是抽象方法.所以实现什么方法就实现什么方法 } }; public class AdpaterDemo { public static void main(String[] args) { Window win= new MyWindow(); win.open(); } }