冒泡排序
冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。
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 {
@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 是一种组合关系，是关联关系的一种（一个类中有另一个类型的实例），是整体和部分之间的关系（比如汽车和轮胎之间），并且代表的整体对象负责构建和销毁部分对象，代表部分的对象不能共享。