java基础知识回顾

最新推荐文章于 2024-01-09 09:29:54 发布

billycoder

最新推荐文章于 2024-01-09 09:29:54 发布

阅读量296

点赞数

分类专栏：林林总总文章标签： java string class object interface classloader

本文链接：https://blog.csdn.net/billycoder/article/details/6856085

版权

林林总总专栏收录该内容

11 篇文章 0 订阅

订阅专栏

好吧.今天下午又写一篇吧.

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();

}

}

billycoder

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础知识回顾

好吧.今天下午又写一篇吧.1. 几个代码块:class Demo2 { {// 构造快 System.out.println("*********构造快**********"); } static { System.out.println("***********类中的静态块**********
复制链接

扫一扫

专栏目录