1607094205 冯二燕

[YLyouthful]

package homework;

import java.util.Scanner;

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);
}

}
//选择排序
class Selectsort extends Basesort {
public void sort(int a[]) {
int t;

		for(int i = 0; i < a.length-1; i++) {
			int min = i;
			for(int j = i; j < a.length-1;j++) {
				if(a[j]<a[min]) {
					t=a[j];
					a[j]=a[min];
					a[min]=t;
				
				}
				
				
			}
			
		}
	}

}

//插入排序
class Insertsort extends Basesort {
public void mian(int a[]) {
int t,j;
for(int i=1;i<a.length;i++) {
t=a[i];
for(j=i-1;j>0&&t<a[j];j--) {
a[j+1]=a[j];
j--;
}
a[j+1]=a[j];
}
}

}

//快速排序
class Quicksort extends Basesort {
public void swap(int a,int b) {
int t;
t=a;
a=b;
b=t;
}
public void sort(int a[],int left,int right) {
int i = left, j = right;
int t;
t=a[i];
while(i!=j){
while(a[j]<t)
j--;
while(a[i]>t)
i++;
swap(a[i],a[j]);

		}
	sort(a,left,i-1);
	sort(a,i+1,right);
	}

}

//测试
class Text2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
			Scanner  scanner= new Scanner(System.in);
			int a[]=new int[10];
			for(int i = 0; i <a.length;i++) {
				a[i]=scanner.nextInt();
			}
			Factory factory=new Factory();
			Basesort   sort1=new Selectsort();
			factory .setsort(sort1);
			factory .dosort(a);
			System.out.println("选择排序后");
			for(int i=0;i<a.length;i++ ) {
				System.out.print(a[i]+" ");
			}
			Basesort   sort2=new Insertsort();
			factory .setsort(sort2);
			factory .dosort(a);
			System.out.println("插入排序后");
			for(int i=0;i<a.length;i++ ) {
				System.out.print(a[i]+" ");
			}
			Basesort   sort3=new Quicksort();
			factory .setsort(sort3);
			factory .dosort(a);
			System.out.println("快速排序后");
			for(int i=0;i<a.length;i++ ) {
				System.out.print(a[i]+" ");
			}
		}

	}

[YLyouthful]

第二次作业
一、为什么有了接口还需要抽象类
1.接口的成员变量只能是public、static和final类型的，而在抽象类中可以定义各种类型的实例变量和静态变量。
2.一个类只能继承一个直接的父类，这个父类有可能是抽象类。一个类可以实现多个接口，一个接口可以同时继承多个接口。但是抽象类可以将具体的方法做成封装，这样就扩张了程序的功能。
3.如果希望在抽象类中增加一个方法，只增加一个默认的合理的实现即可，抽象类的所有实现都自动提供了这个新的方法。对于接口，这是行不通的。虽然可以在骨架实现类中增加一方法的实现来解决部分问题，但这不能解决不从骨架实现类继承的接口实现的问题。

二、简单工厂模式
public interface Car { //设计一个接口
public void run();
}
public class Audi implements Car{ //实现接口

@Override
public void run() {
	// TODO Auto-generated method stub
	System.out.println("奥迪再跑");
}

}
public class Bench implements Car{

@Override
public void run() {
	// TODO Auto-generated method stub
	System.out.println("奔驰再跑");
}

}
public class Factory { //工厂类
public static Audi creataudi() {
return new Audi();

}
public static  Bench creatbench() {
	return new Bench();
	
}

}
public class tsxt2 { //测试类
public static void main(String[] args) {

	Car c1 = Factory. creataudi();
	c1.run();
	Car c2 = Factory. creatbench();
	c2.run();
}

}

运行结果：
奥迪再跑
奔驰再跑

简单工厂模式的优点：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

简单工厂的缺点：没有遵守开放—封闭原则。所谓的“开放-封闭”原则就是开放接口，封闭修改。如果将来需要添加一个开放的算法，那么，在简单工厂模式中，就必须在简单工厂类中添加相应的判断语句！

[YLyouthful]

第三次作业
package peixun;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Maptest {

public static void main(String[] args) {
	Map<String,String> map = new HashMap<String,String>();
	map.put("1","Monday");
	map.put("2","Tuseday");
	map.put("3","Wendsday");
	map.put("4","Thursday");
	
	System.out.println("第一次遍历结果");
	//第一种遍历：通过Map.entrySet遍历key和value   
	Set<Map.Entry<String,String>> set = map.entrySet();
	for(Map.Entry entry:set)
		System.out.println(entry.getKey()+":"+entry.getValue());
	
	/* Map的entrySet（）方法返回一个Set集合，在这个集合里存放了
	     Map.Entry类型的元素每个Map.Entry对象代表Map中的一对键与值。
	      Map.Entry对象中的getKey（）方法返回键,getValue()返回值。
	*/
	
	
	 System.out.println("第二次遍历结果");
	 //第二种遍历：通过Map.entrySet使用iterator遍历key和value
	 Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
	  while (it.hasNext()) {
	   Map.Entry<String, String> entry = it.next();
	   System.out.println( entry.getKey() + ":"+ entry.getValue());
	  }
	  
	  
	  System.out.println("第三次遍历结果");
	  for(String key:map.keySet())
		  //第三种遍历：通过Map.keySet遍历key和value
		  System.out.println( key + ":"+map.get(key));
	  
	  
	  System.out.println("第四次遍历结果");
	  for (String v : map.values()) 
		  //通过Map.values()遍历所有的value，但不能遍历key
		   System.out.println("value= " + v);
		  
	
	
	
}

}

运行结果：
第一次遍历结果
1:Monday
2:Tuseday
3:Wendsday
4:Thursday
第二次遍历结果
1:Monday
2:Tuseday
3:Wendsday
4:Thursday
第三次遍历结果
1:Monday
2:Tuseday
3:Wendsday
4:Thursday
第四次遍历结果
value= Monday
value= Tuseday
value= Wendsday
value= Thursday