Java基础知识总结（3）

冒泡排序

冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。

import java.util.Scanner;
/*
   外层循环控制轮数，内层循环控制每一轮交换的次数
   轮数 = 个数 - 1
   次数 = 个数 - 轮数 
*/
public class BubbleSort{
    public static void sortArray(int[] x){
        int temp;        
        for(int i=0;i<x.length-1;i++){
        //外层循环控制轮数，轮数等于个数减一（最后一位已经确定位置，不用比较）
            for(int j=0;j<x.length-i-1;j++){
            //内层循环控制每一轮的次数，次数等于个数减轮数
                if(x[j]>x[j+1]){
                    x[j]=temp;
                    x[j]=x[j+1];
                    temp=x[j];
                }           
            }
        }
    }
    
    public static void main(String[] args){
        int [] arr = new int[10];//定义数组
        Scanner sc = new Scanner(System.in);
        for(int i=0;i<10;i++){
            //赋值
            arr[i] = sc.NextInt();
        }
        sortArray(arr);
        for(int j=0;j<10;j++){
            System.out.println("the result:",arr[j]);
        }
    }   
}

Java抽象类和接口类的区别

1.相同点

1. 接口和抽象类都不能被实例化。

2. 接口和抽象类中都可以包含抽象方法，继承了接口和抽象类的子类必须实现抽象方法，否则自身也是一个抽象类

2.不同点

1. 接口中可以包含类常量、抽象方法、私有方法、默认方法、内部类。抽象类中可以包含成员变量、成员方法、构造方法、内部类、抽象方法、初始化块。接口中不能包含初始化块和构造方法。

2. 抽象类是单继承的，普通类只能继承一个抽象类，抽象类也只能继承一个抽象类。接口之间是多继承的，一个接口可以继承多个接口，一个类或者抽象类也可以继承多个接口。

子类必须重写父类的抽象方法

1. 父类中写了抽象方法，子类必须重写这个抽象方法

2. 这个子类也是一个抽象类，不是抽象方法

问	答
一个抽象类可不可以实现接口？	接口相比与抽象更具有规范性，接口可以对抽象类进行规范。抽象类可以实现好几个接口，但是Java中没有多继承
一个类可不可以继承抽象类同时实现接口	可以

三大工厂模式

简单工厂模式

定义

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例

属于创建型模式，但它不属于GOF23种设计模式

适用场景

工厂类负责创建的对象较少 客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心

优点

只需要传入一个正确的参数，就可以获取你所需要的对象，无须知道其创建的细节

缺点

工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则不易于扩展过于复杂的产品结构

代码：

我喜欢跟学姐学习Java，抽象一个"学姐"的基类，这是产品的抽象类。

public abstract class SeniorSister{
    /**
     * 描述各班学姐是啥样
     */
    public abstract void desc();
}

先来介绍计算机的学姐（具体的产品类）：

public class JsjSister extends SeniorSister {
    @Override
    public void desc() {
        System.out.println("计算机专业的学姐美丽又大方，但我却没有机会");
    }
}

介绍新媒体专业的学姐（具体的产品类）：

public class XmtSister extends SeniorSister {
    @Override
    public void desc() {
        System.out.println("新媒体专业的学姐闭月羞花，但是却不学习Java");
    }
}public class 

介绍信管专业的学姐（具体的产品类）：

public class  XgSister extends SeniorSister {
    @Override
    public void desc() {
        System.out.println("信管专业的学姐沉鱼落雁，精通Java");
    }
}

学校需要我做出选择（简单工厂类），选择内容如下：

public class SimpleSisterFactory {
    public static final int TYPE_JSJ = 1;//计算机
    public static final int TYPE_XMT = 2;//新媒体
    public static final int TYPE_XG = 3;//信管
​
    public static SeniorSister choiseSister(int type) {
        switch (type) {
            case TYPE_JSJ:
                return new JsjSister();
            case TYPE_XMT:
                return new XmtSister();
            case TYPE_XG:
            default:
                return new XgSister();
        }
    }
}

学校只提供三种个班级的学姐让我选择去跟着学习Java，你说你要那个，他就给你那个。我选择了信管专业的学姐:

/**
 * 简单工厂模式
 */
public class PerferSister{
    public static void main(String[] args){
        SeniorSister zxy = SimpleSisterFactory.choiseSister(SimpleSisterFactory.TYPE_XG);
        zxy.desc();
    }
}
​
​

输出

信管专业的学姐沉鱼落雁，精通Java

工厂方法模式

定义

工厂方法模式（Factory Method Pattern）是指定义一个创建对象的接口，但由实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行

属于创造型设计模式

适用场景

创建对象需要大量重复的代码 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节 一个类通过其子类来指定创建哪个对象

优点

用户只需关心所需产品对应的工厂，无须关心创建细节

加入新产品符合开闭原则，提高了系统的可扩展性

缺点

类的个数容易过多，增加了代码结构的复杂度 增加了系统的抽象性和理解难度

代码:

抽象工厂（ExportFactory）角色：担任这个角色的是工厂方法模式的核心，任何在模式中创建对象的工厂类必须实现这个接口。在实际的系统中，这个角色也常常使用抽象类实现。

具体工厂（ExportHtmlFactory、ExportPdfFactory）角色：担任这个角色的是实现了抽象工厂接口的具体JAVA类。具体工厂角色含有与业务密切相关的逻辑，并且受到使用者的调用以创建导出类（如：ExportStandardHtmlFile）。

抽象导出（ExportFile）角色：工厂方法模式所创建的对象的超类，也就是所有导出类的共同父类或共同拥有的接口。在实际的系统中，这个角色也常常使用抽象类实现。

具体导出（ExportStandardHtmlFile等）角色：这个角色实现了抽象导出（ExportFile）角色所声明的接口，工厂方法模式所创建的每一个对象都是某个具体导出角色的实例。

首先是抽象工厂角色源代码。它声明了一个工厂方法，要求所有的具体工厂角色都实现这个工厂方法。参数type表示导出的格式是哪一种结构，如：导出HTML格式有两种结构，一种是标准结构，一种是财务需要的结构。

public interface ExportFactory {
    public ExportFile factory(String type);
}

具体工厂角色类源代码：

public class ExportHtmlFactory implements ExportFactory{
​
    @Override
    public ExportFile factory(String type) {
        // TODO Auto-generated method stub
        if("standard".equals(type)){
            
            return new ExportStandardHtmlFile();
            
        }else if("financial".equals(type)){
            
            return new ExportFinancialHtmlFile();
            
        }else{
            throw new RuntimeException("没有找到对象");
        }
    }
​
}

public class ExportPdfFactory implements ExportFactory {
​
    @Override
    public ExportFile factory(String type) {
        // TODO Auto-generated method stub
        if("standard".equals(type)){
            
            return new ExportStandardPdfFile();
            
        }else if("financial".equals(type)){
            
            return new ExportFinancialPdfFile();
            
        }else{
            throw new RuntimeException("没有找到对象");
        }
    }
​
}

抽象导出角色类源代码：

public interface ExportFile {
    public boolean export(String data);
}

具体导出角色类源代码，通常情况下这个类会有复杂的业务逻辑。

public class ExportFinancialHtmlFile implements ExportFile{
​
    @Override
    public boolean export(String data) {
        // TODO Auto-generated method stub
        /**
         * 业务逻辑
         */
        System.out.println("导出财务版HTML文件");
        return true;
    }
​
}

public class ExportFinancialPdfFile implements ExportFile{
​
    @Override
    public boolean export(String data) {
        // TODO Auto-generated method stub
        /**
         * 业务逻辑
         */
        System.out.println("导出财务版PDF文件");
        return true;
    }
​
}

public class ExportStandardHtmlFile implements ExportFile{
​
    @Override
    public boolean export(String data) {
        // TODO Auto-generated method stub
        /**
         * 业务逻辑
         */
        System.out.println("导出标准HTML文件");
        return true;
    }
​
}

public class ExportStandardPdfFile implements ExportFile {
​
    @Override
    public boolean export(String data) {
        // TODO Auto-generated method stub
        /**
         * 业务逻辑
         */
        System.out.println("导出标准PDF文件");
        return true;
    }
​
}

客户端角色类源代码：

public class Test {
​
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String data = "";
        ExportFactory exportFactory = new ExportHtmlFactory();
        ExportFile ef = exportFactory.factory("financial");
        ef.export(data);
    }
​
}

复杂工厂模式

定义

抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类

属于创建型设计模式

适用场景

客户端（应用层）不依赖于产品类实例如何被创建、实现等细节 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

优点

具体产品在应用层代码隔离，无须关心创建细节 将一个系列的产品族统一到一起创建

缺点

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口 增加了系统的抽象性和理解难度

代码

interface IProduct1 {  
    public void show();  
}  
interface IProduct2 {  
    public void show();  
}  
  
class Product1 implements IProduct1 {  
    public void show() {  
        System.out.println("这是1型产品");  
    }  
}  
class Product2 implements IProduct2 {  
    public void show() {  
        System.out.println("这是2型产品");  
    }  
}  
  
interface IFactory {  
    public IProduct1 createProduct1();  
    public IProduct2 createProduct2();  
}  
class Factory implements IFactory{  
    public IProduct1 createProduct1() {  
        return new Product1();  
    }  
    public IProduct2 createProduct2() {  
        return new Product2();  
    }  
}  
  
public class Client {  
    public static void main(String[] args){  
        IFactory factory = new Factory();  
        factory.createProduct1().show();  
        factory.createProduct2().show();  
    }  
}

is-a 与 has-a（聚合和组合）

is-a（英语：subsumption，包含架构）是一种继承关系，指的是类的父子继承关系。表达的是一种方式：这个东西是那个东西的一种。例如：长方体与正方体之间--正方体是长方体的一种。正方体继承了长方体的属性，长方体是父类，正方体是子类。

has-a 是一种组合关系，是关联关系的一种（一个类中有另一个类型的实例），是整体和部分之间的关系（比如汽车和轮胎之间），并且代表的整体对象负责构建和销毁部分对象，代表部分的对象不能共享。