java入门基础(四)

文章目录

（一）对象和类

类:类是对象的抽象(不存在)
对象:对象是类的实现(具体存在)
现实生活中先有对象再有类
Java中先有类再有对象

面向对象:是一种思想,在开发过程中关注于对象进行开发

类中相同的行为和特征在Java中如何表示
特征:变量
行为:方法

类的定义:

1.public class 类名{}
2.定义成员变量
格式:public 数据类型变量名
3.定义成员方法
格式:public 返回值数据类型方法名称(参数){}

类的使用(对象):

1.通过类创建对象
格式:类名对象名=new 类名();
2.使用类中的成员变量和成员方法
格式:对象名.成员名称

局部变量和成员变量

成员变量:在类之下
局部变量:在方法中
注意:
通过对象名去使用变量时,只能点出成员变量
在方法中使用变量时,就近原则

this关键字:表示当前对象
在局部变量隐藏成员变量时,使用this进行区分

封装概述:

 面向对象的三大特征之一(封装，继承，多态)
 隐藏类中的内部细节，外界无法直接调用(private)
 封装的原则:
	 将类的某些信息隐藏在类内部，不允许外界直接调用，而是通过该类提供的方法实现对隐藏信息的操作和访问(get、set)
	 private私有化成员变量，提供了对应的get/set方法
	 优点:
	 通过方法控制成员变量，提高了代码的安全性
	 把代码进行封装，提高了代码的复用性
步骤:
	 1.私有化成员变量
	 2.提供对应的getset方法

构造方法

格式:public 类名(参数){
    
    

	}//可以有参，可以无参，构造方法可以重载

注意:类中默认会有一个无参构造如果没有定义构造方法，类中将会自动定义一个默认的无参构造如果定义了构造方法，将会覆盖默认的无参构造
如果定义了有参构造，还要使用无参构造，必须在写一个无参构造
提示:无论是否使用无参构造,都书写无参构造(不写无参构造可能会出现问题,写了无参构造肯定不会出现问题)

（二）String对象

String:

注意:String是特殊的引用数据类型,通常做基本数据类型使用
String的值,不可被更改,可以被共享(创建一个常量时,首先会去常量池中查找,如果没有就创建,如果有就不创建)

String比较:使用equals进行比较两个String是否相同

public class Test {
    
    
    public static void main(String[] args) {
    
    
        String a3=new String("hello");
        String a1="hello";
        String a2="hello";
        Circle c=new Circle("name");
        Circle b=new Circle("name");
        System.out.println(a1.equals(a2));
        System.out.println(a1==a2);
        System.out.println(c.getName()==b.getName());
        System.out.println(c.getName().equals(b.getName()));
        System.out.println(a1.equals(a3));
        System.out.println(a1==a3);
        System.out.println(c.equals(b));
        System.out.println(c==b);
    }
}

在这里插入图片描述

参数传递: 基本数据类型和引用数据类型都不能直接去修改值,但是引用数据类型可以修改之中的元素

String遍历:

String有下标有长度length()
charAt(int index)通过下标获取对应的值

例如:String str="acbdef"
		for(int i=0;i<str.length();i++){
    
    
			sout(str.charAt(i));
		}

String的切分Split

通过split(String regex)
		regex:以什么作为分隔
	通过split(String regex，int limit)
		regex:以什么作为分隔	
		limit:分隔几行
	注意:转义符问题

符号问题:
普通符号:±*/…
特殊符号:\t \n
转义符:
注意:把转义符后第一位符号进行转义

字符串为null时,做判断要注意
1.使用==做判断
2.如果String类型的变量有可能为null时,不能使用equals()

（三）StringBuilder对象

StringBuilder

为什么要用StringBuilder:
	因为:String类型每一次修改值,都会创建一个新的String对象或实例,耗时又浪费资源
StringBuilder构造方法
	StringBuilder()	创建一个空白的StringBuilder对象，不含有任何内容 初始大小为16
	StringBuilder(String str)	根据字符串的内容，创建StringBuilder对象
方法:
	public StringBuilder append(任意类型)	添加数据并返回对象本身
	public StringBuilder reverse()
		返回相反的字符序列
String和StringBuilder相互转换:有一些操作String不能直接实现,而StringBuilder可以
	1.StringBuilder转为String
		public String toString()
	2.String转为StringBuilder
		public StringBuilder(String str)

（四）集合ArrayList:可变的存储模型

创建对象格式:ArrayList<E> 变量名=new 	ArrayList<E>();	
	   例如:ArrayList<String> strs=new 	ArrayList<String>();
	   <E>:泛型 限制存储的数据类型
	   注意:<E>表示当前所存储元素的数据类型,想要存储什么样的数据类型就把E改为什么

练习

一、填空题
1.数组会在内存中开辟一块____连续____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。

2.要获取一个数组的长度，可以通过_____length__属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。

3.__ _声明数组_____仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。

4.创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__ null_____。

5.在Java中有二维数组int [ ] [ ] array={ {1,2,3},{4,5}} ，可以使用____array[0].length_______得到二维数组中第二维中第一个数组的长度。

二、选择题

在Java中，以下程序段能正确为数组赋值的是（ DA ）。（选择二项）

A int a[]={1,2,3,4};
B. int b[4]={1,2,3,4};
C. int c[];c={1,2,3,4};
D. int d[];d=new int[]{1,2,3,4};
数组元素的索引可以是（ D ）。（选择一项）

A 整型常量
B. 整型变量
C. 整型表达式
D. 以上都可以
已知表达式int [] m={0,1,2,3,4,5,6};下面（ B ）表达式的值与数组最大下标数相等。（选择一项）

A m.length()
B. m.length-1
C. m.length()+1
D. m.length+1
在Java中，以下定义数组的语句正确的是（ C D ）。（选择二项）

A int t[10]=new int[ ];
B. char [ ]a=”hello”;
C. String [ ] s=new String [10];
D. double[ ] d [ ]=new double [4][ ];
在Java中,下面代码的输出结果为（ A ）。（选择一项）
public static void main(String[] args) {
int[] arrA = { 12, 22, 8, 49, 3 };
int k = 0; int len = arrA.length;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
if (arrA[i] > arrA[j]) {
k = arrA[i];
arrA[i] = arrA[j];
arrA[j] = k;
}
}
}
for (int i = 0; i < arrA.length; i++) {
System.out.print(arrA[i]);
if (i < arrA.length - 1) {
System.out.print("，");
}
}
}

A 3，8，12，22，49
B. 12，22，8，49，3
C. 49，22，12，8，3
D. 编译错误
分析下面的Java源程序，编译后的运行结果是（ B ）。（选择一项）
import java.util.*;
public class Test {
public static void main(String[ ] args) {
int [ ] numbers=new int[ ]{1,2,3};
System.out.println(Arrays.binarySearch(numbers, 2));
}
}
输出
A 输出：0
B. 输出：1
C. 输出：2
D. 输出：3
以下选项中关于Java中方法的可变参数的说法正确的是（ AC ）。（选择二项）

A 可变参数是JDK1.5增加的内容，用来表示方法的形参
B. 一个方法可以没有可变参数，可以有1个或者多个可变参数
C. 可变参数可以被当作数组参数来处理
D. 可变参数对应的实参可以1个，2个，多个，但不能0个（可以为0个），还可以是一个数组
分析下面的Java程序，编译运行后的输出结果是（ B ）。（选择一项）
public class Example {
String str = new String(“good”);
char[] ch = { ‘a’, ‘b’, ‘c’ };
public static void main(String args[]) {
Example ex = new Example( );
ex.change(ex.str, ex.ch);
System.out.print(ex.str + “and”);
System.out.print(ex.ch);
}
public void change(String str, char ch[]) {
str = “test ok”;
ch[0] = ‘g’;
}
}

A goodandabc
B. goodandgbc
C. test okandabc
D. test okandgbc
以下选项中能够正确创建一个数组的是（ AD ）。（选择二项）

A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][];

三、判断题
1.数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（ T ）
2.数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（ X）
3.声明数组并分配空间后，数组的每个元素将会赋予初始值。（ T ）
4.创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（ T ）
5.数组的主要优点是按照索引查找某个元素效率高，同时按照元素值查询某个元素效率也很高，但是添加和删除元素需要大量移动元素，效率低下。（ X ）
可以利用偏移地址来访问元素，效率高；可以利用折半方法查找元素，，键值对根据元素查下标效率高，效率较高
6.数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。（ T ）
7.Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（ T ）
8.对于数组int[][] t={ {1,2,3},{4,5,6}}来说，t.length等于3，t[0].length等于2（ X ）

四、简答题
1.数组的特点。
答：数组是可以保存一组数据的一种数据结构，它本身也会占用一个内存地址，因此数组是引用类型
·一个数组中只能保存一种类型的数据，可以保存基本类型，也可以保存Object。一个int,一个String是不能同时保存在一个数组内的(如果是对象型数组，注意存放的每一个对象都必须被实例化)。数组的长度规定好即固定，无论其保存的数据是否填满数组，数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差，数组拥有边界检查，尝试获取不在数组范围内的值时，会抛出ArrayIndexOutOfBoundsException异常

2.数组的优缺点
答：优点：使用方便，查询效率比链表高，内存唯一连续的区域缺点：大小固定，不适合动态存储，不方便动态添加

3.冒泡排序的算法
答：按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

五、编码题
1.定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

public class Test {
    
    
	// 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态
	public static void main(String[] args) {
    
    
		String[] strArr = new String[10];
		strArr[0] = "java";		strArr[1] = "html";
		strArr[2] = "sql";		strArr[3] = "android";
		strArr[4] = "javascript";		strArr[5] = "ruby";
		strArr[6] = "c";
		strArr[7] = "c++";
		strArr[8] = ".net";
		strArr[9] = "ios";
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入需要查找的计算机编程语言:");
		String inputStr = scanner.next();
		boolean flag = false;
		for (String string : strArr) {
    
    
			if (string.equals(inputStr)) {
    
    
				flag = true;
			}
		}
		if (flag) {
    
    
			System.out.println("YES");
		} else {
    
    
			System.out.println("NO");
		}
	}
}

package shuzu;

import java.util.Scanner;

//数组查找操作：定义一个长度为10 的一维字符串数组
// ，在每一个元素存放一个单词；然后运行时从命令行输
// 入一个单词，程序判断数组是否包含有这个单词，
// 包含这个单词就打印出“Yes”，不包含就打印出“No”。
public class test1 {
    
    
    public static void main(String[] args) {
    
    
        String[] arr = new String[]{
    
    "aaa", "bbb", "ccc", "ddd", "eee", "hhh", "ggg", "uuu", "rrr", "efds"};
        Scanner sr = new Scanner(System.in);
        String str = sr.next();
        boolean flags=false;
        for (int i = 0; i < 10; i++) {
    
    
            if(str.equals(arr[i])){
    
    
                flags=true;break;

            }

        }
        if (flags==true) System.out.println("yes");
        else System.out.println("no");
    }
}

2.利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。
提示： int num=(int)(n*Math.random());
并找出产生50个这样的随机数中最大的、最小的数，并统计其中大于等于60的有多少个。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		//创建一个长度为50的，每个元素在0-100之间的数组
		int[] arr = getArray(100);
		//遍历数组
		printArr(arr);		
		//获取最大值和最小值
		int min = getMin(arr);
		int max = getMax(arr);
		System.out.println("数组中最大值：" + max + "\t数组中最小值：" + min);
		//统计其中大于等于60的元素个数
		int count = count(arr,60);
		System.out.println("数组中大于或等于60的数有:" + count + " 个");
	}
	//遍历数组
	private static void printArr(int[] arr) {
    
    
		System.out.println("输出数组元素");
		for(int i=0;i<arr.length;i++){
    
    			
			if(i%10 ==0){
    
    
				System.out.println();
			}
			System.out.print(arr[i]+"\t");
		}		
	}
	//获取数组最大值
	private static int getMax(int[] arr) {
    
    
		int max = arr[0];
		for(int i=1;i<arr.length;i++){
    
    
			if(max<arr[i]){
    
    
				max = arr[i];
			}
		}	
		return max;
	}
	//获取数组最小值
	private static int getMin(int[] arr) {
    
    
		int min = arr[0];
		for(int i=0;i<arr.length;i++){
    
    
			if(min>arr[i]){
    
    
				min = arr[i];
			}
		}
		return min;
	}
	// 创建数组 并且初始化50个数据
	public static int[] getArray(int n) {
    
    
		int arr[] = new int[50];
		for (int i = 0; i < 50; i++) {
    
    
			arr[i] = (int) (n * Math.random());
		}
		return arr;
	}
	// 统计数组中大于等于60的数量的方法 思路：使用一个int值计数
	public static int count(int[] arr,int elem) {
    
    
		int count = 0;
		for (int i : arr) {
    
    
			if (i >= elem) {
    
    
				count++;
			}
		}
		return count;
	}
}

public class test2 {
    
    
    public static void main(String[] args) {
    
    
        int[] a = new int[50];
        int count=0;
        for (int i = 0; i < 50; i++) {
    
    
            a[i] = (int) (100 * Math.random());
        }
        int max=a[0];
        int min=a[0];
        for(int i=0;i<50;i++){
    
    
            if(max<a[i])max=a[i];
            if(a[i]>=60)count++;
            if(min>a[i])min=a[i];

        }
        System.out.println(max);
        System.out.println(min);
        System.out.println(count);
    }
}

3.数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

public class Test{
    
    
	public static void main(String[] args) {
    
    
		//定义一个数组，并进行静态初始化。
		int[] arr = {
    
    12,98,50,34,76,87,90,34,67,80};
		//逆序前
		System.out.println("逆序前：");
		printArr(arr);
		//逆序后
		System.out.println("逆序后：");		
		reverseArr(arr);
		printArr(arr);
	}	
	public static void reverseArr(int[] arr) {
    
    
		for(int x=0; x<arr.length/2; x++) {
    
    
			int temp = arr[x];
			arr[x] = arr[arr.length-1-x];
			arr[arr.length-1-x] = temp;
		}
	}
	//遍历数组
	public static void printArr(int[] arr) {
    
    
		System.out.print("[");
		for(int x=0; x<arr.length; x++) {
    
    
			if(x == arr.length-1) {
    
     //这是最后一个元素
				System.out.println(arr[x]+"]");
			}else {
    
    
				System.out.print(arr[x]+", ");
			}
		}
	}
}


public class test3 {
    
    
    public static void main(String[] args) {
    
    
        int[] s=new int[]{
    
    10,20,30,40,50,60,70,80,90,100};
        System.out.println("调换之前");
        printarr(s);
        System.out.println();
        int a;
        for(int i=0;i<=s.length/2;i++){
    
    
            a=s[i];
            s[i]=s[s.length-(i+1)];
            s[s.length-(i+1)]=a;
        }
        printarr(s);

    }
    private static void printarr(int[] arr)  {
    
    
        for(int i=0;i<arr.length;i++){
    
    
            System.out.print(arr[i]+"\t");
        }
    }

}

4.现在有如下的一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}
思路：确定出不为0的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		int oldArr[] = {
    
     1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
		int newArr[] = selectArr(oldArr);
		for (int i : newArr) {
    
    
			System.out.print(i+" ");
		}
	}
	// 去掉数组中值为0的元素的方法
	public static int[] selectArr(int[] arr) {
    
    
		// 1.计算数组中元素不为0的个数
		int count = 0;
		for (int i : arr) {
    
    
			if (i != 0) {
    
    
				count++;
			}
		}
		// 2.创建一个新数组,长度为count
		int newArr[] = new int[count];
		// 3.复制不为0的元素到新数组中
		int size = 0;
		for (int i : arr) {
    
    
			if (i != 0) {
    
    
				newArr[size++] = i;
			}
		}
		return newArr;
	}
}

public class test4 {
    
    
    public static void main(String[] args) {
    
    
        int oldArr[]={
    
    1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
        int count=0;
        for(int i=0;i<16;i++){
    
    
            if(oldArr[i]!=0){
    
    
                count++;
            }
        }
        int newArr[]=new int[count];
        for (int i=0,j=0;i<16;i++){
    
    
            if(oldArr[i]!=0){
    
    
                newArr[j]=oldArr[i];
                System.out.println(newArr[j]);
                j++;
            }

        }


    }
}

5.使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。

public class BinarySearch {
    
    
	public static void main(String[] args) {
    
    		
		int[] array = {
    
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(searchLoop(array, 9));
	}
	/**
	 * 循环二分查找，返回第一次出现该值的位置 
	 * @param array 已排序的数组
	 * @param findValue   需要找的值
	 * @return 值在数组中的位置，从0开始。找不到返回-1
	 */
	public static int searchLoop(int[] array, int findValue) {
    
    
		// 如果数组为空，直接返回-1，即查找失败
		if (array == null) {
    
    
			return -1;
		}
		// 起始位置
		int start = 0;
		// 结束位置
		int end = array.length - 1;
		while (start <= end) {
    
    			
			// 中间位置
			int middle = (start + end) / 2;
			// 中值
			int middleValue = array[middle];
			if (findValue == middleValue) {
    
    
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
    
    
				// 小于中值时在中值前面找
				end = middle - 1;
			} else {
    
    
				// 大于中值在中值后面找
				start = middle + 1;
			}
		}
		// 返回-1，即查找失败
		return -1;
	}
		}

package shuzu;

public class test5 {
    
    
    public static void main(String[] args) {
    
    
        int[] arr=new int[]{
    
    1,2,3,4,5,6,7,8,9};
        System.out.println(searchloop(arr,4));
    }
    private static int searchloop(int[] a,int value){
    
    
        int start=0;
        int end=a.length-1;
        if(a==null){
    
    
            return 0;
        }
        while (start<end){
    
    
            int middle=(start+end)/2;
            if(a[middle]==value){
    
    
                return middle;
            }
            if(a[middle]>value){
    
    
                end=middle;
            }
            if(a[middle]<value){
    
    
                start=middle;
            }
        }
        return -1;
    }
}

6.用二重循环求出二维数组b所有元素的和：

 int[][] b={
    
    {
    
    11},{
    
    21,22},{
    
    31,32,33}}
public class Test {
    
    
	public static void main(String[] args) {
    
    
		int sum=0;
		int[][] b={
    
    {
    
    11},{
    
    21,22},{
    
    31,32,33}};
		for(int i=0;i<b.length;i++){
    
    
			for(int j=0;j<b[i].length;j++){
    
    
				sum += b[i][j];
			}
		}
		System.out.println(sum);
	}
}

package shuzu;

public class test6 {
    
    


    public static void main(String[] args) {
    
    
        int[][] b={
    
    {
    
    11},{
    
    21,22},{
    
    31,32,33}};
        int sum=0;
        for(int i=0;i<b.length;i++) {
    
    
            for (int j = 0; j < b[i].length; j++) {
    
    
                sum = sum + b[i][j];
            }
        }
        System.out.println(sum);


    }
}

六、参考题
1.生成一百个随机数，放入数组，然后排序输出。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		//1.生成100个随机数的数组
		int []arr = createArr();
		//2.从小到大排序 
		arr = sortArr(arr);
		//3.打印
		printArr(arr);
	}
	//生成100个随机数的方法
	public static int[] createArr(){
    
    
		int []arr = new int[100];
		for(int i=0;i<arr.length;i++){
    
    
			arr[i]= (int) (100*Math.random());
		}
		return arr;
	}
	//对数组进行排序的方法
	public static int[] sortArr(int arr[]){
    
    
		int temp;
		for (int i = 0; i < arr.length; i++) {
    
    
			for (int j = 0; j <= i; j++) {
    
    
				if (arr[i] < arr[j]) {
    
    
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		return arr;
	}
	//数组遍历输出打印的方法
	public static void printArr(int []arr){
    
    
		for(int i:arr){
    
    
			System.out.println(i);
		}
	}
}

2.题目：输入某年某月某日，判断这一天是这一年的第几天？
分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。可以定义数组存储1-12月各个月的天数。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		Scanner scanner1 = new Scanner(System.in);
		System.out.print("输出今年是第几年");
		int year = scanner1.nextInt();
		System.out.print("输出今年是第几月");
		int month = scanner1.nextInt();
		System.out.print("输出今年是第几日");
		int day = scanner1.nextInt();
		int daynum = 0; // 天数
		//一年365天
		int[] month1 = new int[] {
    
     31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 }; 
		//闰年366天
		if (year % 400 == 0 && year % 100 != 0 || year % 100 == 0) {
    
    
			month1 = new int[] {
    
     31, 29, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 }; // 闰年里的每个月的天数			
		} 
		//判断这一天是第几天
		for (int index = 1; index <= month; index++) {
    
    
			if (index == 1) {
    
    
				daynum = day;
			} else {
    
    
				daynum += month1[index - 2];
			}
		}
		System.out.println("这一天是这一年的第" + daynum + "天！");
	}
}

3.使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现

public class BinarySearch {
    
    
	public static void main(String[] args) {
    
    		
		int[] array = {
    
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(searchRecursive(array, 0, array.length - 1, 20));
	}
	/**
	 * 执行递归二分查找，返回第一次出现该值的位置	 * 
	 * @param array  已排序的数组
	 * @param start 开始位置
	 * @param end 结束位置
	 * @param findValue  需要找的值
	 * @return 值在数组中的位置，从0开始。找不到返回-1
	 */
	public static int searchRecursive(int[] array, int start, int end,
			int findValue) {
    
    
		// 如果数组为空，直接返回-1，即查找失败
		if (array == null) {
    
    
			return -1;
		}	
		if (start <= end) {
    
    
			// 中间位置
			int middle = (start + end) / 1;
			// 中值
			int middleValue = array[middle];
			if (findValue == middleValue) {
    
    
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
    
    
				// 小于中值时在中值前面找
				return searchRecursive(array, start, middle - 1, findValue);
			} else {
    
    
				// 大于中值在中值后面找
				return searchRecursive(array, middle + 1, end, findValue);
			}
		} else {
    
    
			// 返回-1，即查找失败
			return -1;
		}
	}
}

现在给出两个数组：
数组A：“1，7，9，11，13，15，17，19：；
数组b：“2，4，6，8，10”
两个数组合并为数组c，按升序排列。
要求：使用Arrays类的方法快速实现。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		int data1[] = new int[] {
    
     1, 7, 9, 11, 13, 17, 19 };
		int data2[] = new int[] {
    
     2, 4, 6, 8, 10 };
		int newArr[] = concat(data1, data2);
		print(newArr);
		Arrays.sort(newArr);
		print(newArr);
	}
	public static int[] concat(int src1[], int src2[]) {
    
    
		int len = src1.length + src2.length; // 新数组的大小
		int arr[] = new int[len]; // 新数组
//		int count = 0;
//		for (int i : src1) {
    
    
//			arr[count++] = i;
//		}
//		for (int i : src2) {
    
    
//			arr[count++] = i;
//		}
		// 还可以通过系统的方法拷贝数组
		 System.arraycopy(src1, 0, arr, 0, src1.length); // 拷贝第一个数组
		 System.arraycopy(src2,0,arr,src1.length, src2.length); //拷贝第二个数组
		return arr;
	}
	public static void print(int[] temp) {
    
    
		for (int x = 0; x < temp.length; x++) {
    
    
			System.out.print(temp[x] + "、");
		}
		System.out.println();
	}
}

使用String 中的切分方法，对字符串进行划分，并统计字符串中hello的个数

public class test6 {
    
    


    public static void main(String[] args) {
    
    
        String str="hello,hello,hello,hello,world,";
        System.out.println(str);
        int count=0;
        String[] s=str.split("\\,",5);
        for (int i=0;i<s.length;i++){
    
    
            if (s[i].equals("hello")){
    
    
                count++;
            }
            System.out.println(s[i]);
        }
        System.out.println(count);

    }
}

在这里插入图片描述
一、填空题
1.类是组成Java程序的基本要素，类体有两部分构成：一部分是变量的定义，另一部分是 __ __方法_____的定义。

2.执行Person p = new Person();语句后，将在_ _堆内存__中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。

3.__ _构造方法______是一种特殊方法，它的名字必须与它所在的类的名字完全相同，并且不书写返回值类型，在创建对象实例时由new运算符自动调用。

4.局部变量的名字与成员变量的名字相同，若想在该方法内使用成员变量，必须使用关键字__ this___。

5.使用关键字__ this___ 来调用同类的其它构造方法，优点同样是以最大限度地代码的利用程度，减少程序的维护工作量。

6.用关键字__ __static_____修饰的成员变量是类变量，类变量是指不管类创建了多少对象，系统仅在第一次调用类的时候为类变量分配内存，所有对象共享该类的类变量。

7.使用static修饰的变量称为静态变量，静态变量可以有两种访问方式，分别是类名.静态变量名和_ 对象名.静态变量名__。

8.在一个类文件中的关键字package，import，class出现的可能顺序是_package import class_ __________。

9.__ package_______关键字作为Java源文件的第一条非注释性语句，指明该源文件定义的类所有的包。

10.__ _____java.lang__包是Java语言的核心类库，它包含了运行Java程序必不可少的系统类，使用该包下的类和接口不需要使用import导入。

二、选择题

在Java中，以下程序编译运行后的输出结果为（ D ）。（选择一项）
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}

A 6
B. 34
C. 8
D. 7
分析如下Java程序的代码所示，则编译运行后的输出结果是（ C ）。（选择一项）
public class Test {
int count=9;
public void count1(){
count=10;//局部变量改变了全局变量的值，因此值就变了
System.out.println(“count1=”+count);
}
public void count2(){
System.out.println(“count2=”+count);
}
public static void main(String[ ] args) {
Test t=new Test();
t.count1();
t.count2();
}
}

A count1=9;
count2=9;
B. count1=10;
count2=9;
C. count1=10;
count2=10;
D. count1=9;
count2=10;
以下语句中关于Java构造方法的说法错误的是（ B ）。（选择一项）

A. 构造方法的作用是为创建对象进行初始化工作，比如给成员变量赋值
B. 一个Java类可以没有构造方法，也可以提供1个或多个构造方法
C. 构造方法与类同名，不能书写返回值类型
D. 构造方法的第一条语句如果是super()，则可以省略，该语句作用是调用父类无参数的构造方法
在Java中关于静态方法，以下说法中正确的是（ AC ）。（选择两项）

A 静态方法中不能直接调用非静态方法
B. 非静态方法中不能直接调用静态方法(递归)
C. 静态方法可以用类名直接调用
D. 静态方法里可以使用this
下列选项中关于Java中类方法的说法错误的是（ AC ）。（选择二项）

A 在类方法中可用this来调用本类的类方法
B. 在类方法中调用本类的类方法时可直接调用
C. 在类方法中只能调用本类中的类方法
D. 在类方法中调用实例方法需要先创建对象

三、判断题
1.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。( T )

2.如果没有为类中的某些成员赋初始值，Java会为类成员赋予固定的初始值，如数值变量的值为0，布尔变量的值为true，未初始化的引用为null。（ X ）//布尔类型初始值为false

3.Java中所有的变量，不管是成员变量还是局部变量（），在使用前都必须进行初始化。（ X ）
4.在Java中对象可以赋值，只要使用赋值运算符即可，相当于生成了一个各属性与赋值对象相同的新对象。（ X ）
5.System.out.println(“Hello java!”)中out是System类的一个静态成员变量。（ T ）
6.构造方法用于创建对象，一般不允许有任何返回值，因此需要在构造方法返回类型处标注为void。（ X ）
7.Java语言为所有的Java程序自动导入包“java.lang”，因此Java程序可以直接用“java.lang”中的类和接口。（ T ）

四、简答题
1.面向过程和面向对象的区别。（5分）
2.答：面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对类和对象的关系
象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
3.类和对象的关系
答：类是对象的一个模板，而对象是类的一个具体实例。
4.构造方法的作用和特征
答：作用：对类进行初始化；构造方法的特征：方法名与类名一致，没有返回值类型
5.this关键字的作用和用法
答：this的作用是在类中通过this访问自身的属性和方法

五、编码题

1.请定义一个交通工具(Vehicle)的类其中有: 属性：速度(speed)、体积(size)等，方法：移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速的方法对速度进行改变。

public class Vehicle {
    
    		
	private int size;
	private int speed;	
	public static void main(String[] args) {
    
    
		Vehicle ve = new Vehicle();
		ve.setSize(10);//设置初始体积
		ve.setSpeed(30);//设置初始速度
		ve.move();//调用移动方法
		ve.speedUp();//给交通工具减速
		ve.speedDown();//加速
		
	}
	/** 行进	 */
	public void move(){
    
    
		System.out.println("行进中......，速度 "+speed+"km/h" );
	}
	/** 设置速度	 */
	public void setSpeed(int speed){
    
    
		this.speed = speed;
		System.out.println("初始速度设置为:"+speed+" km");
	}
	/** 设置体积	 */
	public void setSize(int size){
    
    
		this.size = size;
		System.out.println("初始体积设置为:"+size+" m^3");
	}
	/** 加速20 */
	public void speedUp(){
    
    
		this.speed+=20;
		System.out.println("速度增加20后为:"+speed+" km");
	}
	/** 减速10 */
	public void speedDown(){
    
    
		this.speed-=10;
		System.out.println("减速10后为:"+speed+" km");
	}
}

2.编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。该类中应该有两个私有属性：姓名（name）和年龄（age）。定义构造方法用来初始化数据成员。再定义显示（display()）方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。

public class Person {
    
    
	private String name;
	private int age;
	/** 在构造器中初始化成员变量 */
	public Person(String name,int age){
    
    
		this.name = name;
		this.age = age;
	}
	public static void main(String[] args) {
    
    
		Person p = new Person("张三",18);
		p.display();
	}
	/** 显示姓名和年龄  */
	public void display(){
    
    
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
	}
}

3.定义一个圆类——Circle，在类的内部提供一个属性：半径®，同时提供两个方法：计算面积（ getArea() ）和计算周长（getPerimeter()）。通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。

public class Circle {
    
    
	private int r;
	/** 无参构造 */
	public Circle(){
    
    }
/** 有参构造，初始化半径*/
	public Circle(int r){
    
    
		this.r=r;
	}
	/** 也可以使用setR方法初始化半径 */
	public void setR(int r){
    
    
		this.r = r;
	}
	/**计算 面积 */
	public void getArea(){
    
    
		double area = Math.PI * r * r;//从Math工具类得到π的值
		System.out.println("圆的面积为："+area);
	}
	/** 计算 周长 */
	public void getPerimeter(){
    
    
		double zc = Math.PI * 2 * r;
		System.out.println("圆的周长为："+zc);
	}
}
/** 测试 */
public class Test {
    
    
	public static void main(String[] args) {
    
    
		Circle c = new Circle(4);//初始半径为4,使用构造初始化
		c.getArea();
		c.getPerimeter();
	}
}

4.构造方法与重载：定义一个网络用户类，要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入，其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。

public class People {
    
    
	private String id;
	private String password;
	private String email;
	/** 无参构造 */
	public People(){
    
    
		
	}
	/** 全参构造 */
	public People(String id,String password,String email){
    
    
		this.id = id;
		this.password=password;
		this.email = email;
	}
	public People(String id,String password){
    
    
		this.id = id;
		this.password=password;
		this.email=id+"@gameschool.com";
	}
	public void show() {
    
    
		System.out.println("编号："+this.id);
		System.out.println("密码："+this.password);
		System.out.println("邮件："+this.email);
	}
	public static void main(String[] args) {
    
    
		//调用全参构造
		People p1 = new People("sxt0001","123456","[email protected]");
		p1.show();
		//调用无参构造
		People p2 = new People("sxt0002","654321");
		p2.show();
	}
}

六、可选题
1.定义一个类 Calculaion，其中包含四个方法：加（add()）、减（sub()）、乘（times()）和除（div()）。创建一个具有 main()函数的类。在 main()函数中创建一个 Calculation 的实例对象并对其中的方法进行调用。

public class Calculaion {
    
    		
	private double a;
	private double b;
	public Calculaion(double a,double b){
    
    
		this.a=a;
		this.b=b;
	}
	public void add(){
    
    
		System.out.println("a加b ："+(a+b));
	}
	public void sub(){
    
    
		System.out.println("a减b ："+(a-b));
	}
	public void times(){
    
    
		System.out.println("a乘b ："+(a*b));
	}
	public void div(){
    
    
		System.out.println("a除以b ："+(a/b));
	}
	public static void main(String[] args) {
    
    
		Calculaion c = new Calculaion(7.0,3.0);
		c.add();
		c.sub();
		c.times();
		c.div();
	}
}

2.定义一个类 Draw ，在类中提供 3 个方法：输出直角三角形（drawTrian()）、输出矩形（drawRec()）及平行四边形（drawPra()）。通过方法可以输出由“*” 组成的一个图形。同时在类中包含两个属性：星号的个数（count）、行数（lines）。最后在测试类中进行调用。

public class Draw {
    
    
	private int count, lines;
	public Draw(){
    
    }
	public Draw(int count, int lines){
    
    
		this.count=count;
		this.lines=lines;
	}
	/** 直角三角形 */
	public void drawTrina() {
    
    
		for (int i = 0; i < lines; i++) {
    
    //共lines行
			for (int j = 0; j < i; j++) {
    
    //每次增加1
				System.out.print("*");
			}
			System.out.println();//换行
		}
	}
/** 输出矩形 */
	public void drawRec(){
    
    
		for (int i = 0; i < lines; i++) {
    
    
			for (int j = 0; j < count; j++) {
    
    //每行数量固定
				System.out.print("*");
			}
			System.out.println();
		}
	}
	/** 平行四边形 */
	public void drawPra(){
    
    
		for (int i = 0; i < lines; i++) {
    
    
			for(int k=0;k<i;k++){
    
    
				System.out.print(" ");
}				
			for (int j = 0; j < count; j++) {
    
    
				System.out.print("*");
			}
			System.out.println();
		}
	}
	public static void main(String[] args) {
    
    
		Draw d = new Draw(5,5);
		//d.drawTrina();
		//d.drawRec();
		d.drawPra();
	}
}

3.创建一个空调，并调用制冷、制热、通风功能。空调包含的属性有品牌、匹数、温度，功能有加热、制冷、通风等功能。

public class AirConditioning {
    
    
	// 空调属性
	String name;
	String pinpai;
	String hp;// 匹数
	int tempeture;
	// 定义制冷行为
	void cool() {
    
    
		tempeture--;
	}
	// 定义加热行为
	void hot() {
    
    
		tempeture += 7;
	}
	//通风功能
	void ventilate(){
    
    
		System.out.println("空气通畅，温度不变");
	}
	// 主函数
	public static void main(String[] args) {
    
    
		AirConditioning kt = new AirConditioning();
		kt.hp = "2匹";
		kt.tempeture = 20;
		kt.pinpai = "格力";
		kt.cool();
		System.out.println("空调的温度是" + kt.tempeture);
		kt.hot();
		System.out.println("空调的温度是" + kt.tempeture);		
		kt.ventilate();
	}
}

4.定义一个表示学生信息的类 Student，要求如下：
（1）类 Student 的属性如下：
sNO 表示学号； sName 表示姓名； sSex 表示性别； sAge 表示
年龄；sJava：表示 Java 课程成绩。
（2）类 Student 带参数的构造方法：
在构造方法中通过形参完成对成员变量的赋值操作。
（3）类 Student 的方法成员：
getNo（）：获得学号；
getName（）：获得姓名；
getSex（）：获得性别；
getAge（）获得年龄；getJava（）：获得 Java 课程成绩

public class Student {
    
    
	String sNO ; 
	String sName; 
	String sSex; 
	int sAge;
	int sJava;		
	public Student(String sNO, String sName, String sSex, int sAge, int sJava) {
    
    
		this.sNO = sNO;
		this.sName = sName;
		this.sSex = sSex;
		this.sAge = sAge;
		this.sJava = sJava;
	}
	public String getsNO() {
    
    
		return sNO;
	}
	public String getsName() {
    
    
		return sName;
	}
	public String getsSex() {
    
    
		return sSex;
	}
	public int getsAge() {
    
    
		return sAge;
	}
	public int getsJava() {
    
    
		return sJava;
	}
}

（4）根据类 Student 的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生 Java 语言成绩的平均值，以及计算并输出他们 Java 语言成绩的最大值和最小值。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		Student s1 = new Student("sxt0001", "张三", "男",18,90);
		Student s2 = new Student("sxt0002", "李四", "女",15,92);
		Student s3 = new Student("sxt0003", "王五", "男",17,93);
		Student s4 = new Student("sxt0004", "赵六", "男",21,95);
		Student s5 = new Student("sxt0005", "钱七", "男",19,97);
		
		System.out.println("\t学号\t姓名\t姓别\t年龄\t成绩");
		System.out.println("\t"+s1.getsNO()+"\t"+s1.getsName()
				+"\t"+s1.getsSex()+"\t"+s1.getsAge()+"\t"+s1.getsJava());
		System.out.println("\t"+s2.getsNO()+"\t"+s2.getsName()
				+"\t"+s2.getsSex()+"\t"+s2.getsAge()+"\t"+s2.getsJava());
		System.out.println("\t"+s3.getsNO()+"\t"+s3.getsName()
				+"\t"+s3.getsSex()+"\t"+s3.getsAge()+"\t"+s3.getsJava());
		System.out.println("\t"+s4.getsNO()+"\t"+s4.getsName()
				+"\t"+s4.getsSex()+"\t"+s4.getsAge()+"\t"+s4.getsJava());
		System.out.println("\t"+s5.getsNO()+"\t"+s5.getsName()
				+"\t"+s5.getsSex()+"\t"+s5.getsAge()+"\t"+s5.getsJava());
		int d = (s1.getsJava()+ s2.getsJava()+ s3.getsJava()
				+ s4.getsJava()+ s5.getsJava())/5;
		System.out.println("java语言平均成绩："+d);
	}
}

ArryayList练习

public class test1 {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> str=new ArrayList<>();
        System.out.println(str);
        produce(str);
        System.out.println(str);
        posort(str);
        System.out.println(str);
    }

    public static void produce(ArrayList<String> str) {
    
    
        String big = "大王";
        String small = "小王";
        String[] a = new String[]{
    
    "黑桃", "红桃", "方块", "梅花"};
        String[] b = {
    
    "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        str.add(big);
        str.add(small);
        for (int i = 0; i < a.length; i++) {
    
    
            for (int j = 0; j < b.length; j++) {
    
    
                str.add(a[i] + b[j]);
            }
        }
    }

    public static void posort(ArrayList<String> str){
    
    
        Random r=new Random();
        for(int i=0;i<str.size();i++){
    
    
            int a=r.nextInt(54);
            int b=r.nextInt(54);
            String x=str.get(a);
            String y=str.get(b);
            str.set(a,y);
            str.set(b,x);
        }
    }

}