Java

Java散乱(一、面向对象)

2018-06-03  本文已影响4人  强某某

面向对象

- 成员变量：声明在类里，方法外(有默认值，有public,private,protected,缺省值共四种修饰符，存在于堆空间中)
- 局部变量：方法内部的变量，代码块内部，形参(局部变量不能有修饰符，与所在方法修饰符相同)(必须初始化赋值，存在与栈空间中)
- 属性：类中的成员变量
- 行为：类中的成员方法

/**
 * 饿汉式：开发时候常用
 * 
 * @author Administrator
 * 
 */
class Singleton {
    private static Singleton sg = new Singleton();

    private Singleton() {

    }

    public static Singleton getSingle() {
        return sg;
    }
}

* 懒汉式

        /**
 * 懒汉式：可能存在线程安全问题
 * 
 * @author Administrator
 * 
 */
class Singleton {
    private static Singleton sg;

    private Singleton() {

    }

    public static Singleton getSingle() {
        if (sg == null) {
            sg = new Singleton();
        }
        return sg;
    }
}

补充：final修饰很多时候是为了避免变量释放

public class INClass{
   void innerClass(final String str){
        class IClass{
            IClass(){
                System.out.println(str);
            }
        }
        IClass ic=new IClass();
    }
  public static void main(String[] args){
      INClass inc=new INClass();
      inc.innerClass("Hello");
  }
}
说明：final修饰str，否则方法执行完毕会释放str，但是此时内部类还需要使用str。
所以利用final修饰避免释放保证内部类使用正常。此处java的内存回收应该不是引用计数，
否则不会出现这种情况，具体后期研究。

抽象类

当功能内部一部分实现是确定，一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类实现

public class D {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //下面两种等效
//      ABTemplate ab=new Template();
        Template ab=new Template();
        ab.getTime();
    }

}
abstract class ABTemplate{
    public abstract void code();
    public void getTime() {
        long t1=System.currentTimeMillis();
        this.code();
        long t2=System.currentTimeMillis();
        System.out.println(t2-t1);
    }
}
class Template extends ABTemplate{

    @Override
    public void code() {
        int total=0;
        for (int i = 0; i < 1000; i++) {
            total+=i;
        }
        System.out.println(total);
    }
}
说明：这样形式就可以实现一部分固定，一部分子类实现。

接口

public interface One {
    //接口中只能放常量，所以即使不加public static final修饰，默认也会加上
    public static final int num=0;
    String info="测试";
    //接口中只能有抽象方法，所以下面两者等效，默认加上public abstract修饰
    public abstract void test();
    void getName();
}
class BB implements One{

    public void test() {
        System.out.println(num);
    }

    public void getName() {
        System.out.println(info);
    }
    
}

定义一个创建对象的接口，让子类决定实例化哪一个类

public class FactoryTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        WorkFactory wf=new StudentWorkFactory();
        wf.getWork().doWork();//学生写作业
        WorkFactory wf1=new TeacherWorkFactory();
        wf1.getWork().doWork();//老师批改作业
    }

}

interface WorkFactory{
    Work getWork();
}
class StudentWorkFactory implements WorkFactory{

    public Work getWork() {
        return new StudentWork();
    }
    
}
class TeacherWorkFactory implements WorkFactory{

    public Work getWork() {
        return new TeacherWork();
    }
    
}
interface Work{
    void doWork();
}
class StudentWork implements Work{

    public void doWork() {
        System.out.println("学生写作业");
    }
}
class TeacherWork implements Work{

    public void doWork() {
        System.out.println("老师批改作业");
    }
}

为其他对象提供一种代理以控制对这个对象的访问
代理类负责了被代理类的执行

public class TestProxy {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Object b=new Px1();
        b.action();
    }

}
interface Object{
  void  action();
}
class Px1 implements Object{
    Px2 p2;
    public Px1() {
        p2=new Px2();
    }

    public void action() {
        System.out.println("代理执行开始");
        p2.action();
        System.out.println("代理执行结束");
    }
}
class Px2 implements Object{

    public void action() {
        System.out.println("被代理执行开始");
        System.out.println("被代理执行结束");
    }
}
输出：
代理执行开始
被代理执行开始
被代理执行结束
代理执行结束

内部类

匿名内部类
public class InnerClass {

    /**
     * @param args
     */
    public static void main(String[] args) {
        InnerClass ic=new InnerClass();
        ic.show(new Imple() {
            public void test() {
                System.out.println("测试");
            }
        });
    }
    public  void show(Imple p) {
        p.test();
    }
    
    interface Imple{
        void test();
    }
}
上一篇 下一篇

猜你喜欢

热点阅读