周小结 -选择排序，内部类及抽象类与接口的区别

选择排序

public class SlectSort {
	public static void main(String[] args) {
		//静态初始化一个数组
		int arr[] = {12,67,89,34,23,47};
		//方法调用
		bianLi(arr);
		System.out.println("选择排序结果");
		selectSort(arr);
		bianLi(arr);
	}
	//定义一个遍历输出的方法
	public static void bianLi(int arr[]) {
		System.out.print("[");
		for(int i = 0 ; i < arr.length ; i++) {
			if(i == arr.length - 1) {
				System.out.println(arr[i]+"]");
			}else {
				System.out.print(arr[i]+",");
			}
		}
	}
	//选择排序
	public static void selectSort(int arr[]) {
		for(int m = 0 ; m < arr.length ; m++) {
			for(int n = m +1 ; n < arr.length ;n++) {
				if(arr[m] > arr[n]) {
					int temp = arr[m] ;
					arr[m] = arr[n] ;
					arr[n] = temp ;
				}
			}
		}
	}
}

抽象类与接口的区别

1）成员区别
	成员变量：
		抽象类：抽象类中既可以是常量也可以是变量
		接 口:只能是常量
	成员方法：
		抽象类：及可以是抽象方法，也可以是非抽象方法
		接口：只能是抽象方法
	构造方法：
		抽象类：存在构造方法，有参/无参对数据进行初始化赋值
		接口：没有构造方法
2）关系区别
	类与类：不论这个类是抽象类还是具体类，都是继承关系，可多层继承但只能是但继承
	类与接口：实现关系，一个类继承另一个类的同时，可以实现多个接口
	接口与接口：继承关系，支持单继承以及多继承
3）设计理念的区别
	抽象类：在抽象类多态中使用，存在继承关系
	接口：体现的是一个事物的扩展功能，子实现类实现，存在实现关系

成员内部类（非静态）：在外部类成员位置定义

//测试类访问成员内部类成员方法
class Outer{
	private int num = 20 ;
	class Inner{
		public void show(){
			System.out.println(num);
		}
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//创建对象
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

成员内部类（被private修饰）

//测试类访问被private修饰过的成员内部类的成员方法
class Outer{
	private int num = 20 ;
	private class Inner{
		public void show(){
			System.out.println(num);
		}
	}
	public void method() {
		Inner i = new Inner();
		i.show();
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//创建对象
		Outer o = new Outer();
		o.method();		
	}
}

成员内部类（被static修饰）

//测试类访问被static修饰过的成员内部类的成员方法
class Outer{
	private static int num = 20 ;
	static class Inner{
		public void show(){
			System.out.println(num);
		}
		public static void show2(){
			System.out.println(num);
		}
	}
}
//测试类
public class Test2 {
	public static void main(String[] args) {
		//创建对象
		Outer.Inner oi = new Outer.Inner();
		oi.show();
		oi.show2();
		System.out.println("-------------");
		//当成员内部类被static修饰过的同时，成员内部类的方法也被static修饰过，那么可以直接用下面的方法调用
		Outer.Inner.show2();
	}
}

局部内部类：在外部类的成员方法中定义的类

//测试类访问局部内部类成员变量
class Outer{
	private int num = 20 ;
	int sum = 30 ;
	public void method() {
		class Inner{
			public void show(){
				System.out.println(num);
			}
			public void show2(){
				System.out.println(sum);
			}	
		}
		Inner i = new Inner();
		i.show();
		i.show2();
	}
}
//测试类
public class Test2 {
	public static void main(String[] args) {
		//创建对象
		Outer o = new Outer();
		o.method();	
	}
}

匿名内部类：是局部内部类中的一种

本质：一个带具体实现的父类或者父接口的匿名的子类对象。
格式：
new 类名/接口名(){
 	方法重写 ；  
};
eg:使用名内部类来完成返回值是一个接口类型的代码
//接口 
interface Inner{ 
	public abstract void  show() ;
}
class Outer{
	public static Inner show2() {
		 return new Inner() {
			public void show() {
				System.out.println("爱生活，爱JAVA");
			}
		}; 
	}		
}
//测试类
public class Test1 {
	public static void main(String[] args) {
		Outer.show2().show();
	}
}

抽象类多态

抽象类不能被实例化。
抽象成员必须在抽象类中。
抽象成员必须标记为abstract，并且不能有任何实现。
子类继承抽象类后，必须把父类中的所有抽象成员重写。
抽象成员的访问修饰符不能是private。
抽象类虽然是有构造函数的，但是不能被实例化。
如果父类的抽象方法中有参数，那么继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。
如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候也必须要有返回值。