JavaSE.20190428.可变参数.数组的排序.Arrays工具类(API).面向对象(一).

一.可变参数

     1.参数的个数不确定,可以是0个可以是多个,参数的数据类型必须相同
        注: 可变参数必须要写在参数列表的最后
        格式     ... ,数据类型 ... 参数名-->可变参数
        操作可变参数,要通过使用数组的方式,编译器会隐式的在内部为我们构建一个数组,存储可变参数的值;

public class Demo02{
	public static void main(String[] args){
		getSum(1,1,1,2,3,4,5);
		test(123,new String[]{"哈哈"},new String[]{"呵呵"});
	}
	//求多个数的和
	public static void getSum(int ... a){
		System.out.println("hhaahha"+a);
		int sum=0;
		for(int i:a){
			sum+=i;
		}
		System.out.println(sum);
	}
	public static void test(int name1,String[] ...name2){
		System.out.println(name1);
		System.out.println(name2);
		for(String[] a:name2){
			for(String s :a){
				System.out.println(s);
			}
		}
	}
}

二.数组的排序  <了解>
     1.数组:
               int[ ] arr={9,10,5,7,4}
        1)冒泡排序: 每两个相邻数之间进行比较,找到一个最小的或者最大的进行交换,把它放在这一轮的最后一个位置
                i=1~arr.length-1    两个数中的第一个j的变化范围
             第一轮: 9,5,7,4,10      [0,arr.length-1)          能确定一个最大值,放在最后,下一轮不用比较
             第二轮: 5,7,4,9          [0,arr.length-2)   
             第三轮: 5,4,7             [0,arr.length-3)   
             第四轮: 4,5                [0,arr.length-4)
        2)选择排序: 拿主场数和后面的每一个位置的数据比较大小,确保这一轮结束后,主场位置存放的是这一轮中的最大或最小者    
             轮数 i      1~arr.length-1        主场数的索引 i            与主场数比较的数的范围:
              0     第一轮: 1,9,5,7,4 ,18            0                        [i+1,arr.length-1]    
              1     第二轮:    3,5,7,4 ,8              1                    
              2     第三轮:      7,5,4 ,8               2
              3     第四轮:             5,4               3

public class ArraySort03{
	public static void main(String[] args){
		int[] arr={9,10,5,7,4};
		//print(bubble(arr));
		print(choice(arr));
		System.out.println(find(arr,15));
	}
	//选择排序  升序
	public static int[] choice(int[] arr){
		//外层循环i控制轮数,主场数的索引
		int max=0;  //记录每一轮中最大数据的索引
		for(int i=0;i<arr.length-1;i++){
			max=i;
			//与主场数比较的数的范围 m
			for(int m=i+1;m<=arr.length-1;m++){
				if(arr[max]>arr[m]){
					max=m;
				}
			}
			//max 最大数的位置
			if(max!=i){
				int temp=arr[i];
				arr[i]=arr[max];
				arr[max]=temp;
			}
		}
		return arr;
	}
	//冒泡排序
	public static int[] bubble(int[] arr){
		//外层循环控制比较轮数  1~arr.length-1 比如5个数,比较4轮
		for(int i=1;i<=arr.length-1;i++){
			//内层循环的变量控制i 没两个数比较的第一个数的索引j 和 j+1  j的范围:0  ~ arr.length-i-1
			for(int j=0;j<arr.length-i;j++){
				if(arr[j]<arr[j+1]){
					int temp=arr[j+1];
					arr[j+1]=arr[j];
					arr[j]=temp;
				}
			}
		}
		return arr;
	}
	//二分法查找:
	//数组已经升序排序
	//查找数组中指定的数据,找到返回它的索引,没有找到返回-1
	public static int find(int[] arr,int i){
		int min=0;
		int max=arr.length-1;
		int mid=(min+max)/2;
		while(i!=arr[mid]){
			if(i>arr[mid]){
				min=mid+1;
			}else if(i<arr[mid]){
				max=mid-1;
			}
			if(max<min){
				return -1;
			}
			mid=(min+max)/2;
		}
		return mid;
	}
	//遍历数组
	public static void print(int[] arr){
		for(int i:arr){
			System.out.println(i);
		}
	}
}

三.Arrays 工具类 (API)  <了解>

     1.较为常用的:

        static boolean equals(int[] a, int[] a2) 如果两个指定的 int 型数组彼此相等，则返回 true。
        static String toString(int[] a) 返回指定数组内容的字符串表示形式。     
        static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序。 
        static void sort(int[] a, int fromIndex, int toIndex) 对指定 int 型数组的指定范围按数字升序进行排序。         
        static void fill(int[] a, int val)  将指定的 int 值分配给指定 int 型数组的每个元素。
        static int binarySearch(int[] a, int key) 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
        static int[] copyOf(int[] original, int newLength)  
        static int[] copyOfRange(int[] original, int from, int to)  将指定数组的指定范围复制到一个新数组。 
        static boolean deepEquals(Object[] a1, Object[] a2)  如果两个指定数组彼此是深层相等 的，则返回 true。 
        static String deepToString(Object[] a)  返回指定数组“深层内容”的字符串表示形式
              数组的使用 ***
                      使用,遍历..

四.面向对象(一)  ★★★★★

     1.面向对象和面向过程区别:
        相同点: 都是一种思维方式,是一种思想
        不同点: 面向过程:"我应该怎么去做?" 然后一步一步去实现
                     面向对象:"我应该让谁来做?" 不关注具体如何实现,关注的是对象
     2.面向对象的优点:
           1)更贴近于现实生活
           2)面向对象可以将复杂的问题简单化
           3)面向对象贴近管理者的角度,面向过程体现于执行者
    3.如何使用面向对象的思维方式进行编程:
           想要程序和现实生活挂上关系,所以提供的两个概念:  类  对象
             类: 现实生活中一系列事物的模板
             对象: 具体的某个事物
    4.自定义类|模板类|javabean
        1)手机能做什么???   打电话,上网,发短息,刷抖音...   动词  --->功能  成员方法
        2)手机的特征???     颜色  价钱   品牌  尺寸...     名词  --->属性  成员变量
            事物:属性  功能
            public class 类名{
                 //成员变量
               修饰符 数据类型  变量名=赋值;
                //成员方法
               修饰符 返回值类型 方法名([参数]){
                   方法体
                }
            }

    5.使用引用数据类型:
        1)导包    哪些情况不需要导:①java.lang包下的内容  ②同包下的类不需要导包
        2)创建类型的引用:
               格式:  数据类型 引用名|变量名 = new 数据类型();  --->创建一个对象,new是用来创建对象的
        3)使用功能|属性
               引用.功能名字()|属性名字

      示例一:

//创建手机 类
public class Phone05{
	//颜色
	String color;
	//价钱
	double money;
	//品牌
	String brand;
	//打电话 不加static修饰的方法叫做成员方法
	public void call(){
		System.out.println("从前有个人长得像电话,出门就被打了...");
	}
}

public class PhoneTest06{
	public static void main(String[] args){
		//1.创建手机对象
		Phone05 p1=new Phone05();   //创建一个真实存在的手机对象,名字叫做p1
		//2.给属性赋值
		p1.color="黑色";
		p1.brand="苹果";
		p1.money=8000;
		System.out.println(p1.color);
		System.out.println(p1.money);
		System.out.println(p1.brand);
		p1.call();
		Phone05 p2=new Phone05();
		p2.call();
	}
}

      示例二:

//快捷键 
/*
 * 事物:汽车
 * 	属性: 颜色  品牌  轱辘
 * 	功能: 跑
 */
public class Car01 {
	//颜色  
	String color;
	//品牌  
	String brand;
	//轮胎个数
	int num;
	//功能: 跑
	public void run(){
		//syso-->alt+/-->enter
		System.out.println("一辆"+num+"个轱辘的"+color+"的"+brand+"在跑...");
	}
}

//测试Car类
public class CarTest02 {
	//main-->alt+/
	public static void main(String[] args) {
		//构建小汽车对象
		Car01 car1=new Car01();
		car1.color="红色";
		car1.brand="玛莎拉蒂";
		car1.num=2;
		
		car1.run();
		System.out.println(car1);
	}
}

         针对上面小轿车的示例做内存分析: