java 2018/11/10--2018/11/21 总结

1、泛型

        在定义类或方法的时候没有明确数据类型，而是使用<字母>来标记

        注：泛型只能是引用化类型，不能是基本类型

        举例：若想对一数组进行输出，这数组可以是：整型数组、浮点型、字符串数组。那么最好选择泛型...

        public class Jenerics {

       //泛型方法

       public static <E> void printArray(E[] inputArray) {

             //输出数组

             for(E element:inputArray) {

                    System.out.printf("%s",element);

             }

             System.out.println();

       }

       

       public static void main(String[] args) {

             

             //创建不同类型数组

             Integer[] intArray= {1,2,3,4,5};

             Double[] doubleArray= {1.1,2.1,3.1,4.1,5.1};

             String[] s= {"1","2","3","4","5"};

             

             System.out.println("Int型：");

             printArray(intArray);

             

             System.out.println("Double型：");

             printArray(doubleArray);

             System.out.println("String型：");

             printArray(s);

       }

}

 

        泛型类：

            public class Jenerics<E>{

       E value;

       

       public void add(E value) {

             this.value=value;

       }

       

       public E get() {

             return value;

       }

       

       public static void main(String[] args) {

             

             Jenerics<Integer> intValue=new Jenerics<Integer>();

             Jenerics<String> s=new Jenerics<String>();

             

             intValue.add(10);

             System.out.println("整型数值为："+intValue.get());

             

             s.add("泛型类");

             System.out.println("字符串为："+s.get());

       }

}

        

注：当获得这个类的实例的时候需要明确泛型的具体类型，无具体类型默认为Object

    如：上例中改为：

            

 

        是正确的

        若改为：

 

                    错误为Cannot make a static reference to the non-static type E

            说明在创建实例的时候就要明确类型而不能是泛型

2、电商例子中学到的

        ArrayList的使用，需要专门使用一个模块进行讲述

3、外部类与内部类、匿名类

    什么是外部类？什么是内部类？什么时候会用到

    定义在类中的类叫内部类，内部类的外面一层就是外部类

    

     内部类可以由匿名内部类，局部内部类，非静态内部类，静态内部类

 

     //外部类   

     public class Outer {

       

       //实例、成员

        static int n;

       

       //类、模板

       static int y;

       

       //内部类（内聚-封装）

       public static class Inner {

             void foo() {

                    n++;//此处的n应该定义为静态

             }

       }

}

            public class Demo {

       public static void main(String[] args) {

             //外部类对象

             Outer o=new Outer();

             

             //要使用内部类，内部类要加上限定符public

             //是实例化内部类

             //Inner加上static就可以不用o.

             Inner i=new Inner();

       }

}

我一直困惑的匿名内部类

    当前有用到的是监听器。

    匿名内部类只能使用一次，用来简化代码

    只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

为什么要用到内部类？

    内部类不会理会外部类继承了某个实现，它会独立继承一个实现

    内部类可以有更好的封装，除了该外围类，其他类都不能访问

4、设计模式（初学）

    单例模式（Singleton）：只有唯一一个实例。作用： 用来解决一个全局使用的类频繁的创建和销毁，从而节约系统资源，一个对象处理一个连接，这个连接比较短    

    初始化方式：

        a)类加载

        b）延时加载

        c)内部类

        特点：

            1）构造方法私有化

            2）提供一个公开的静态方法（类方法）

            //单例模式

public class Singleton {

       

       //类加载时初始化，不一定要static，但本例子需要

       //static Singleton instance=new Singleton();

       

       static Singleton instance;

       

       //构造方法私有

       private Singleton(){

             

       }

       

       //未加static是错误的，因为构造方法写成私有的，无法被类意外的函数调用，只能通过getInstance函数，加上static可以用类名调用改方法。

       //延时加载需要synchronized同步方法，相当于别人还未执行完该方法，其他人不可用，但是性能会差

       public synchronized static Singleton getInstance() {

             //延时创建

             if(instance==null) {

                    instance=new Singleton();

             }

             return instance;

       }

       

       public static void main(String[] args) {

             System.out.println(Singleton.getInstance());

             System.out.println(Singleton.getInstance());

       }

}

        

        //内部类初始化

            public class Single {

       private Single() {

             

       }

       

       //类方法

       public static Single getInstance() {

             return Holder.instance;

       }

       

       //内部类

       static class Holder{

             static Single instance=new Single();

       }

}

       

    工厂模式（office）：把具体的产品封装起来，不允许外界调用，只能通过特定的方法调用

        例如：office的例子，可以把文件如何创建的方法封装起来，外界通过特定方式调用，这里只传工厂方法，其他的类就没上传

    public class Factory {

       /**

        * 静态工厂方法

        *

        * @param type

        * @return

        */

       public static Doc create(Type type) {

             Doc doc = null;

             switch (type) {

             case WORD:

                    doc = new Word();

                    break;

             case EXCEL:

                    doc = new Excel();

                    break;

             case PPT:

                    doc = new Ppt();

             }

             return doc;

       }

       public static Doc create(Type type, String title) {

//           Doc doc = create(type);

//           doc.setTitle(title);

             

             Doc doc = null;

             switch (type) {

             case WORD:

                    doc = new Word(title);

                    break;

             case EXCEL:

                    doc = new Excel(title);

                    break;

             case PPT:

                    doc = new Ppt(title);

             }

             return doc;

       }

}

     构造器/构建者/Builder

        当想要创建多个初始化参数时，可以使用Builder

        对象创建的过程完成任意多个数的初始化参数，使用内部类间接完成对象的创建，一般将外部类的构造方法保护起来，即设置为私有

        public class User {

       // 将构造方法保护起来

       private User() {

       }

       String name;

       String e_mail;

       String phone;

       // 使用类名可以进行调用

       public static class Builder {

             static String name;

             static String e_mail;

             static String phone;

             public Builder() {

             }

             public static String getName() {

                    return name;

             }

             public Builder setName(String name) {

                    Builder.name = name;

                    return this;

             }

             public static String getE_mail() {

                    return e_mail;

             }

             public Builder setE_mail(String e_mail) {

                    Builder.e_mail = e_mail;

                    return this;

             }

             public static String getPhone() {

                    return phone;

             }

             public Builder setPhone(String phone) {

                    Builder.phone = phone;

                    return this;

             }

             public User builder() {

                    User user = new User();

                    return user;

             }

       }

       public static void main(String[] args) {

             User u = new User.Builder().setName("xx").setE_mail("g").builder();

             System.out.println(String.format("姓名：%s\n邮件：%s",Builder.getName(),Builder.getE_mail()));

       }

}

    观察者模式(Observe)

            当对象间存在一对多的关系时，则使用观察者模式。比如当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式，符合面向对象的设计，功能不重点突出，突出架构，成员变量越少越好。

        例子:被观察者更新了消息，那么观察者一方也要做出相应的变化

        /**

 * 观察者，看不到和数据直接相关的

 *

 * @author thinkpad_ljj

 *

 */

public class App {

       

       public static void main(String[] args) {

             

             Ui ui = new Ui();

             

             Data data2 = new Data();

             

             Data data = new Data();

             

             //添加观察者

             data.addObserver(ui);

             //data.addObserver(o);

             data2.addObserver(ui);

             

             //状态改变

             data.setF(36);

             data.setF(39);

             

       }

       

}

        import java.util.Observable;

/**

 * 被观测的主题

 *

 * @author thinkpad_ljj

 *

 */

public class Data extends Observable{

       

       //改变的数据

       double f;

       

       public void setF(double f) {

             this.f = f;

             

             //设置状态为已改变，必须写的

             setChanged();

             

             //通知观察者,不带参数则被观察者自己查看

             //notifyObservers();

             

             //带参数，观察者都会看到

             notifyObservers(f);

       }

       

       //返回更新的数据

       public double getF() {

             return f;

       }

       

}

        import java.util.Observable;

import java.util.Observer;

/**

 * 打印输出变化

 *

 * @author thinkpad_ljj

 *

 */

public class Ui implements Observer {

       double n;

       

       public void display() {

             System.out.println("更新:" + n);

       }

       //Observable是被观测者的，指明被观察的是哪个

       @Override

       public void update(Observable o, Object arg) {

             

             n = (double) arg;

             

             display();

       }

}

结果：

5、接口回掉

        回调是双向的调用模式

        接口回调：可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么接口变量就可调用被类实现的接口方法

        选择JAVA课本中的例子进行说明

        public class Example {

       public static void main(String[] args) {

             ShowMessage sm;//声明接口变量

             sm = new TV();//接口变量中存放对象的引用

             sm.显示商标("长城");//接口回调

             sm = new PC();//接口变量中存放对象的引用

             sm.显示商标("联想");//接口回调

       }

}

interface ShowMessage{

       void 显示商标(String s);

}

class TV implements ShowMessage{

       @Override

       public void 显示商标(String s) {

             System.out.println(s);

       }

}

class PC implements ShowMessage{

       @Override

       public void 显示商标(String s) {

             System.out.println(s);

       }

       

}