1607084106-肖芳敏 - Githubissues

goodwoman commented 6 years ago

public class BaseSort {
public void sort(int []a){
System.out.println("排序算法");
}

}
class Factory{
private BaseSort sort;
//依赖注入
public void setSort(BaseSort sort) {
this.sort=sort;
}
public void doSort(int []a) {
sort.sort(a);
}
}
public class InsertSort extends BaseSort {
public void sort(int a[]) {
int len=a.length;
int t=0,i,j;
//进行len-1次循环，每次循环都将下表为i的元素插入到它的前面已排好的队列中
for( i=1;i<len;i++) {
//进行i次循坏，每次循环都将下标为i的元素与下标为j的元素比较，找到比它小的元素，然后插入到它的后面，如果没有找到，就不操作。
j=i;
t=a[i];
while(j>0&&t<a[j-1]) {
a[j]=a[j-1];
j--;
}
a[j]=t;
}
for(int m=0;m<a.length;m++) {
System.out.print(a[m]+" ");
}

}
}
public class QuickSort extends BaseSort {
public void sort(int a[],int low,int high) {
int start=low;
int end=high;
int k=a[low];
//从后往前比较；
while(end>start) {
while(end>start&&a[end]>=k)//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
end--;
if(a[end]<=k) {
int t=a[end];a[end]=a[start];a[start]=t;
}
while(end>start&&a[start]<=k) //如果没有比关键值大的，比较下一个，直到有比交换值大的交换位置
start++;
if(a[start]>=k) {
int t=a[start];a[start]=a[end];a[end]=t;
}
}//此时第一次循坏比较结束，关键值的位置已经确定了。左边的值比关键值小，右边的值比关键值大。
if(start>low) sort(a,low,start-1);//左边序列
if(end<high) sort(a,end+1,high);//右边序列

for(int i=0;i<a.length;i++) 
    System.out.print(a[i]+" ");
}
}
public class SelectSort extends BaseSort {
public void sort(int a[]) {
for(int i=0;i<a.length;i++) {
int k=i;//k表示最小元素的下标
for(int j=k+1;j<a.length;j++) {
if(a[j]<a[k]) {k=j;
}//将最小值放到序列末尾
if(i!=k) {
int t=a[i];a[i]=a[k];a[k]=t;
}
for(int m=0;m<a.length;m++) {
System.out.print(a[m]+" ");
}
}
}
}
}
import java.util.Scanner;

public class Text {
public static void main(String[] args){
@SuppressWarnings("resource")
Scanner s=new Scanner(System.in);
int a[]=new int[10];//数组初始化
for(int i=0;i<a.length;i++) {
a[i]=s.nextInt();
System.out.print(a[i] + " ");//输出数组排序前的顺序
}
System.out.println("使用选择排序后的序列：");
Factory f=new Factory();
BaseSort base=new SelectSort();
f.setSort(base);
f.doSort(a);
System.out.println("使用插入排序后的序列：");
BaseSort quick=new QuickSort();
f.setSort(quick);
f.doSort(a);
System.out.println("使用快速排序后的序列：");
BaseSort insert=new InsertSort();
f.setSort(insert);
f.doSort(a);
}
}

goodwoman commented 6 years ago

1.为什么有了接口还要抽象类？答：（1）抽象类不仅可以有抽象方法还可以有非抽象方法，它提供可以实现方法；而接口里的方法都必须是抽象方法，它不可以实现，所以在需要实现抽象类的地方需要用到抽象类，仅靠接口无法实现某些功能。（2）类要实现一个接口必须要实现接口里定义的所有方法，这时可能接口中的某些方法可能是类所不需要的，这就造成了麻烦；而继承抽象类可以有选择的去重写需要用到的方法，需要注意的是必须实现里面的所有抽象方法。（3）接口中定义的变量默认是public static final型，且必须给初值，所以实现类中不能重新定义，也不能改变其值。抽象类中变量默认的是frindly型，其值可以在子类中重新定义，也可以重新赋值。 2.学习至少一种设计模式（1）工厂模式：适合需要大量创建产品且产品具有共同的接口的情况。

public  interface Sender(){  //建立了一个接口
public void Sender();
}
public class A implements Sender(){  //创建了类A，且A实现上面的接口
public void Sender(){
System.out.printl("This is A:");
}
}
public class B implements Sender(){  //创建了类B，且实现了接口Sender
public void Sender(){
System.out.printl("This is B:");
}
}

public class SendFactory{ //建立了一个工厂类，用于建立类A、B的对象 public Sender produceA(){ return new A(); } public Sender produceB(){
return new B(); } public class Factory Text{ //创建了一个测试类 public static void main(String args[]){ SendFactory fl=new SendFactory(); Sender s=fl.produceA(); s.Send(); //创建了类A的对象，并调用了A的方法 } } 注意：该工厂模式可以有多个接口和多个工厂类，工厂类中也可以有多个方法（可以将方法设置成静态的，就可以直接调用方法），具体可以根据需求进行改进。优点：用此类模式，在创建很多的类对象时，若前面的类有所变更，就不需要在每个类对象处进行更改，只需在工厂类中该即可，省去了很多的麻烦。（2）单例模式：保证在一个JVM中，该对象只有一个实例存在。

public class Singleton{
private Singleton(){  //私有构造方法，防止被实例化
}
private static  class SingletonFactory{  //使用内部类建立实例并来维持单例
private static Singleton intance=new Singleton();
}
public static Singleton getInstance(){ //获取实例
return  SingletonFactory.instance;
}
public Object readResolve(){  //保证序列化后前后保持一致
return getInstance();
}
}

优点：（1）当某些类创建比较频繁时用此类方法可以避免很大的系统开销。（2）省去new操作符，降低系统内存的使用频率。（3）保证核心交易服务器独立控制整个流程。

问：在单例模式中为什么使用内部类可以维持单例？

goodwoman commented 6 years ago

1.为什么有了接口还要抽象类？答：（1）抽象类不仅可以有抽象方法还可以有非抽象方法，它提供可以实现方法；而接口里的方法都必须是抽象方法，它不可以实现，所以在需要实现抽象类的地方需要用到抽象类，仅靠接口无法实现某些功能。（2）类要实现一个接口必须要实现接口里定义的所有方法，这时可能接口中的某些方法可能是类所不需要的，这就造成了麻烦；而继承抽象类可以有选择的去重写需要用到的方法，需要注意的是必须实现里面的所有抽象方法。（3）接口中定义的变量默认是public static final型，且必须给初值，所以实现类中不能重新定义，也不能改变其值。抽象类中变量默认的是frindly型，其值可以在子类中重新定义，也可以重新赋值。 2.学习至少一种设计模式（1）工厂模式：适合需要大量创建产品且产品具有共同的接口的情况。

public  interface Sender(){  //建立了一个接口
public void Sender();
}
public class A implements Sender(){  //创建了类A，且A实现上面的接口
public void Sender(){
System.out.printl("This is A:");
}
}
public class B implements Sender(){  //创建了类B，且实现了接口Sender
public void Sender(){
System.out.printl("This is B:");
}
}
public class SendFactory{ //建立了一个工厂类，用于建立类A、B的对象
public Sender produceA(){
return new A();
}
public Sender produceB(){
return new B();
}
public class Factory Text{ //创建了一个测试类
public static void main(String args[]){
SendFactory fl=new SendFactory();
Sender s=fl.produceA();
s.Send(); //创建了类A的对象，并调用了A的方法
}
}

注意：该工厂模式可以有多个接口和多个工厂类，工厂类中也可以有多个方法（可以将方法设置成静态的，就可以直接调用方法），具体可以根据需求进行改进。优点：用此类模式，在创建很多的类对象时，若前面的类有所变更，就不需要在每个类对象处进行更改，只需在工厂类中该即可，省去了很多的麻烦。（2）单例模式：保证在一个JVM中，该对象只有一个实例存在。

public class Singleton{
private Singleton(){  //私有构造方法，防止被实例化
}
private static  class SingletonFactory{  //使用内部类建立实例并来维持单例
private static Singleton intance=new Singleton();
}
public static Singleton getInstance(){ //获取实例
return  SingletonFactory.instance;
}
public Object readResolve(){  //保证序列化后前后保持一致
return getInstance();
}
}

优点：（1）当某些类创建比较频繁时用此类方法可以避免很大的系统开销。（2）省去new操作符，降低系统内存的使用频率。（3）保证核心交易服务器独立控制整个流程。

问：在单例模式中为什么使用内部类可以维持单例？ @goodwoman

Write

goodwoman commented 6 years ago

111

goodwoman commented 6 years ago

用三种方法遍历ArrayList：

package test3.xiugai;
import java.util.*;//可引用Java的util包中的所有类型及方法
public class Cats {
    public static void main(String args[]) {
        List Dogs=new ArrayList();//创建一个空的数组链表对象Dogs,数组的长度可变化
        Dogs.add("2 years old ,500g");
        Dogs.add("4 years old ,1000g");
        Dogs.add("5 years old ,1500g");
        Dogs.add("3 years old ,700g");
        Dogs.add("1 years old ,300g");
        Dogs.add("4 years old ,800g");
        Dogs.add("8 years old ,1200g");
        Dogs.add("9 years old ,1500g");
        Dogs.add("6 years old ,3000g");
        Dogs.add("7 years old ,4300g");
        //调用add方法给对象赋值
        System.out.println("使用for遍历集合的结果为：");
        for(int i=0;i<Dogs.size();i++) {
            System.out.println("狗的年龄及体重："+Dogs.get(i));
        }
        System.out.println("采用foreach遍历集合的结果为：");
        for(Object s:Dogs) {
            System.out.println("狗的年龄及体重："+s);

        }
        System.out.println("使用for遍历集合的结果为：");
        for(Iterator it=Dogs.iterator();it.hasNext();) {
            System.out.println("狗的年龄及体重："+it.next());

        }
    }
}

运行的结果为：使用for遍历集合的结果为：狗的年龄及体重：2 years old ,500g 狗的年龄及体重：4 years old ,1000g 狗的年龄及体重：5 years old ,1500g 狗的年龄及体重：3 years old ,700g 狗的年龄及体重：1 years old ,300g 狗的年龄及体重：4 years old ,800g 狗的年龄及体重：8 years old ,1200g 狗的年龄及体重：9 years old ,1500g 狗的年龄及体重：6 years old ,3000g 狗的年龄及体重：7 years old ,4300g 采用foreach遍历集合的结果为：狗的年龄及体重：2 years old ,500g 狗的年龄及体重：4 years old ,1000g 狗的年龄及体重：5 years old ,1500g 狗的年龄及体重：3 years old ,700g 狗的年龄及体重：1 years old ,300g 狗的年龄及体重：4 years old ,800g 狗的年龄及体重：8 years old ,1200g 狗的年龄及体重：9 years old ,1500g 狗的年龄及体重：6 years old ,3000g 狗的年龄及体重：7 years old ,4300g 使用for遍历集合的结果为：狗的年龄及体重：2 years old ,500g 狗的年龄及体重：4 years old ,1000g 狗的年龄及体重：5 years old ,1500g 狗的年龄及体重：3 years old ,700g 狗的年龄及体重：1 years old ,300g 狗的年龄及体重：4 years old ,800g 狗的年龄及体重：8 years old ,1200g 狗的年龄及体重：9 years old ,1500g 狗的年龄及体重：6 years old ,3000g 狗的年龄及体重：7 years old ,4300g

android-nuc / 17_Java_Train

1607084106-肖芳敏 #10