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.相同点

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

2.不同点

接口中可以包含类常量、抽象方法、私有方法、默认方法、内部类。抽象类中可以包含成员变量、成员方法、构造方法、内部类、抽象方法、初始化块。接口中不能包含初始化块和构造方法。
抽象类是单继承的，普通类只能继承一个抽象类，抽象类也只能继承一个抽象类。接口之间是多继承的，一个接口可以继承多个接口，一个类或者抽象类也可以继承多个接口。

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

父类中写了抽象方法，子类必须重写这个抽象方法
这个子类也是一个抽象类，不是抽象方法

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

三大工厂模式

简单工厂模式

定义

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

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

适用场景

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

优点

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

缺点

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

代码：

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

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

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

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

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

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

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

public class  XgSister extends SeniorSister {@Overridepublic 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{
@Overridepublic ExportFile factory(String type) {// TODO Auto-generated method stubif("standard".equals(type)){return new ExportStandardHtmlFile();}else if("financial".equals(type)){return new ExportFinancialHtmlFile();}else{throw new RuntimeException("没有找到对象");}}

}

public class ExportPdfFactory implements ExportFactory {
@Overridepublic ExportFile factory(String type) {// TODO Auto-generated method stubif("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{
@Overridepublic boolean export(String data) {// TODO Auto-generated method stub/*** 业务逻辑*/System.out.println("导出财务版HTML文件");return true;}

}

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

}

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

}

public class ExportStandardPdfFile implements ExportFile {
@Overridepublic 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 stubString 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();  }  
}