类间关系和内部类和数组

Final关键词

定义Pepole类，运用了final修饰方法eat()，该方法不能被改写，但可以随类进行继承。
用final修饰的类，不能有子类。

内部成员类定义方式

外部类.成员类 对象名= new 外部类（）.new 内部类。

局部内部类
在成员方法内部定义的类，该类用于方法内部，限局部使用，外部不能被调用。

package test;

public class Pepole {
	
   final public void eat() {
	   System.out.println("人吃饭");  
	   
   }
   
   
}

package test;

final public class Hunan extends Pepole{

	
	//成员内部类
	
	class Xiangtan{
		public void eat() {
			System.out.println("湘潭吃灯芯糕");			
		}
		

		public void teSe() {
			//省略1万行
			
			//局部内部类
			class Binglang{
					public void show() {
						System.out.println("湘潭生产槟榔");
					}
				
				}	
					
		     Binglang bl=new Binglang();
			 bl.show();		///
				
			}		
		
	}
	
		

		
	public static void main(String args[]) {
		final int MAXLENG=100;
				
		int x,y,z[];
		x=0;
		y=x;
		z=new int[5];
		
		int a[]=new int[MAXLENG];
		int b[][]=new int[MAXLENG][3];
		
		b[0][0]=0;
		System.out.println(b[0][0]);
		
		a[0]=10;
		a[1]=20;
		
		System.out.println(a[0]);
		System.out.println(a[1]);
			
		
		
		
		
	}
	
}

数组的定义
变量类型 数组名 = new 变量类型[长度]；
JAVA中数组下标从0开始。

作业上机练习排序
把三种排序方式集合到一个类中，形成一个排序的包装类，并添加降序排列的方法和打印数组的方法。

实现举例
创建包装排序类

创建测试类test
在测试类中实例例化Sorts类，传入数组，并选择升序和降序，可以打印数组
有实力的同学，可以在类中添加创建随机数组，可以根据传入数组的长度，自动创建随机数组的值，再打印数组排序。

接口定义代码参考

package com.java.stdy;

public interface ISorts {
   public void setSorts(int[] list);
   public void selectionSort();
   public void printSorts(); 	
}

实现类代码参考

package com.java.stdy;
import java.util.Random;
public class Sorts implements ISorts {
	private int[] list;
	@Override
	public void setSorts(int[] list) {
		 this.list=list;		
	}
	
	public void initSort(int len){
		int[] tlist=new int[len];
		Random r= new Random();
		
		for(int i=0;i<=len-1;i++){
		  tlist[i]=r.nextInt(100);
		}
		list=tlist;
		
	}
	

	@Override
	public void selectionSort() {
	 int len=list.length-1;
	 int t;
	 for(int i=0;i<=len;i++){		 
		 for(int j=i+1;j<=len;j++){
			 if(list[i]>list[j]){
			   t=list[j];
			   list[j]=list[i];
			   list[i]=t;			   
			 }	 
		 }		 
	 }		
	}
   
	//降序排列
	public void descSorts(){
	  
	  int len=list.length;
	  int[] tlist=new int[len];  	  
	  for(int i=0;i<=len-1;i++){
		  tlist[i]=list[len-1-i];		  
	  } 	  
	  list=tlist;		
	}
	
	//升序排列
	public void ascSorts(){
		selectionSort();
	}
	
	
	
	
	@Override
	//打印数组
	public void printSorts() {
	 int len=list.length;
		for(int i=0;i<=len-1;i++){
			System.out.print(list[i]+" ");			
		}
		System.out.println("");
	}
	//打印提示
	public void print(String s) {
			System.out.println(s);
			}		
	
	

}

调用 测试类

package com.java.stdy;

public class Test01 {
	public static void main(String args[]){
		
		//演示手动输入数组
		Sorts s1=new Sorts();
		s1.print("演示手动动输入数组");
		int[] list= {23,56,87,23,78,1,6,8,86,0};
		s1.setSorts(list);
		s1.printSorts();
		s1.selectionSort();
		s1.print("升序排列");
		s1.printSorts();
		s1.descSorts();
		s1.print("降序");
		s1.printSorts();
		s1.ascSorts();
		s1.print("再升序");
		s1.printSorts();
		
		
		
		//演示自动动输入数组
		
		Sorts s=new Sorts();	
		s.print("\n演示自动动输入数组");
		s.initSort(30);
		s.print("初始化20个数");
		s.printSorts();
		s.selectionSort();
		s.print("升序排列");
		s.printSorts();
		s.descSorts();
		s.print("降序");
		s.printSorts();
		s.ascSorts();
		s.print("再升序");
		s.printSorts();

		
		
		
	}
	
}

运行结果

演示手动动输入数组
23 56 87 23 78 1 6 8 86 0 
升序排列
0 1 6 8 23 23 56 78 86 87 
降序
87 86 78 56 23 23 8 6 1 0 
再升序
0 1 6 8 23 23 56 78 86 87 

演示自动动输入数组
初始化20个数
37 12 36 9 18 80 24 17 77 40 43 98 46 80 70 69 32 74 90 41 56 82 22 94 5 34 44 62 46 23 
升序排列
5 9 12 17 18 22 23 24 32 34 36 37 40 41 43 44 46 46 56 62 69 70 74 77 80 80 82 90 94 98 
降序
98 94 90 82 80 80 77 74 70 69 62 56 46 46 44 43 41 40 37 36 34 32 24 23 22 18 17 12 9 5 
再升序
5 9 12 17 18 22 23 24 32 34 36 37 40 41 43 44 46 46 56 62 69 70 74 77 80 80 82 90 94 98 

-------------------------------------------------------------------------------------

相关知识点

排序算法
01 冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

比较相邻的元素。如果第一个比第二个大，就交换它们两个；

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

针对所有的元素重复以上的步骤，除了最后一个；

重复步骤1~3，直到排序完成。

1.2 动图演示

02 选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；

第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

n-1趟结束，数组有序化了。

2.2 动图演示

03 插入排序（Insertion Sort）
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；

取出下一个元素，在已经排序的元素序列中从后向前扫描；

如果该元素（已排序）大于新元素，将该元素移到下一位置；

重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

将新元素插入到该位置后；

重复步骤2~5。

3.2 动图演示

上机练习： 要求把三种方法，集成到类的成员方法，可以实现升序和降序排列
同时可以公共打印出数组

更所算法

类间关系

1. 泛化（Generalization）继承
   【泛化关系】：是一种继承关系, 表示一般与特殊的关系, 它指定了子类如何特化父类的所有特征和行为. 例如：老虎是动物的一种, 即有老虎的特性也有动物的共性。

【代码】：

public class Animal{
 
}
public class Tiger extends Animal{
    //继承Animal类
}

【箭头指向】：带三角箭头的实线，箭头指向父类

2. 实现（Realization）
【实现关系】：是一种类与接口的关系, 表示类是接口所有特征和行为的实现.

【代码】：

public interface IBrush {
    //    声明一个接口（注意:接口不是类）
}
public class PenBrush implements IBrush {
    //    实现接口IBrush 
}

【箭头指向】：带三角箭头的虚线，箭头指向接口

3. 关联（Association)
   【关联关系】分为 聚合（Aggregation） 组合(Composition)
   【聚合关系】：是整体与部分的关系, 且部分可以离开整体而单独存在. 如车和轮胎是整体和部分的关系, 轮胎离开车仍然可以存在.

聚合关系是关联关系的一种，是强的关联关系；关联和聚合在语法上无法区分，必须考察具体的逻辑关系。
【代码体现】：成员变量。

【代码】：如下。

/**
* 汽车类
*/
public class Car{
    //引擎
    private Engine engine;
    //轮胎
    private Tire tire;
}
 
/**
* 引擎类
*/
public class Engine{
 
}
 
/**
* 轮胎类
*/
public class Tire{
 
}

【箭头及指向】：带空心菱形的实心线，菱形指向整体

组合(Composition)
【组合关系】：是整体与部分的关系, 但部分不能离开整体而单独存在. 如公司和部门是整体和部分的关系, 没有公司就不存在部门.组合关系是关联关系的一种，是比聚合关系还要强的关系，它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期

【代码体现】：成员变量。

【代码】：如下。

//公司类
public class Company{
    //
    private Department department;
 
}
//部门类
public class Department{
 
 
}

【箭头及指向】：带实心菱形的实线，菱形指向整体

各种关系的强弱顺序：
泛化 = 实现 > 组合 > 聚合 > 关联 > 依赖