Java学习记录2

 1：抽象方法和抽象类

        抽象方法： 使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

抽象类： 包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

例：抽象方法和抽象类的使用

//抽象类
abstract class Animal {
    abstract public void shout();  //抽象方法
}
class Dog extends Animal { 
    //子类必须实现父类的抽象方法，否则编译错误
    public void shout() {
        System.out.println("汪汪汪！");
    }
    public void seeDoor(){
        System.out.println("看门中....");
    }
}
//测试抽象类
public class TestAbstractClass {
    public static void main(String[] args) {
        Dog a = new Dog();
        a.shout();
        a.seeDoor();
    }
}

2：接口

        可以更加规范的对子类约束，接口中的所有方法都是抽象方法。全面地专业地实现了：规范和具体实现的分离。

接口的声明格式：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
常量定义；  
方法定义；
}

      1. 访问修饰符：只能是public或默认。

      2. 接口名：和类名采用相同命名机制。

      3. extends：接口可以多继承。

      4. 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。

      5. 方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。

要点：

      1. 子类通过implements来实现接口中的规范。

      2. 接口不能创建实例，但是可用于声明引用变量类型。

      3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

例：接口的使用

public class text_interface {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入单位数");
		int age = scanner.nextInt();
		yearchild yue = new yearchild();
		yue.print(age);
		monthchild zi = new monthchild();
		zi.print(age);
	}
}
/**child接口*/
interface child{
	int month=30;
	int year=365;
	void print(int a);
}
/**yearchild类*/
class yearchild implements child{
	public void print(int a) {
		System.out.println("age="+year*a);
	}
}
/**monthchild类*/
class monthchild implements child{
	public void print(int a) {
		System.out.println("age=" + month* a);
	}
}

3：内部类

        内部类的作用：

      1. 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。

      2. 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。

      3. 接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整。

        内部类的使用场所：

      1. 由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，在只为外部类提供服务的情况下可以优先考虑使用内部类。

      2.  使用内部类间接实现多继承：每个内部类都能独立地继承一个类或者实现某些接口，所以无论外部类是否已经继承了某个类或者实现了某些接口，对于内部类没有任何影响。

4：String类（又称为不可变字符序列）

        String位于java.lang包中，Java程序默认导入java.lang包下的所有类

例：

String str1 = "Hello";
String str2 = "World";
String s = str1 + str2;    //s = "HelloWorld";
String str3 = "18" + 19;    //str3 = "1819" ;(这里的“+”为字符串连接符，而并非加法运算符)

 5：String类常用的方法

方法	解释说明
char charAt(int index)	返回字符串中下标为index的字符
boolean equals(String other)	如果字符串与other相等，返回true；否则，返回false
boolean equalsIgnoreCase(String other)	如果字符串与other相等（忽略大小写），则返回true；否则，返回false
int indexOf(String str)	返回从头开始查找第一个字符串str在字符串中的索引位置。如果未找到字符串str，则返回-1
lastIndexOf()	返回从末尾开始查找第一个字符串str在字符串中的索引位置。如果未找到字符串str，则返回-1
int length()	返回字符串的长度
String replace(char oldChar,char newChar)	返回一个新串，它是通过用newChar替换此字符串中出现的所有oldChar而生成的
boolean startsWith(String prefix)	如果字符串以preifx开始，则返回true
boolean endsWith(String prefix)	如果字符串以preifx结尾，则返回true
String substring(int beginIndex)	返回一个新字符串，该串包含从原始字符串beginIndex到串尾
String substring(int beginIndex,int endIndex)	返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex-1的所有字符
String toLowerCase()	返回一个新字符串，该串将原始字符串中的所有大写字母改为小写字母
String toUpperCase()	返回一个新字符串，该串将原始字符串中的所有小写字母改成大写字母
String trim()	返回一个新字符串，该串删除了原始字符串头部和尾部的空格

 6：数组的拷贝

	System.arraycopy(src, srcPos, dest, destPos, length);
//将src数组里的元素值赋给dest数组的元素，其中srcpos
//指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

 7：Arrays工具类的使用

需要加头文件   import java.util.Arrays;

System.out.println(Arrays.toString(a));  ：  将字符数组a打印；

Arrays.sort(a);   ：   将字符数组a排序（从小到大）

8：冒泡排序

for(int j = 0 , j<values.length , j++)    //values为数组名
    for(int i = 0 , j<values.length-1-j , i++)
        //比较大小，换顺序
        if(values[i]>values[i+1]){
            int temp=0;
            temp = values[i];
            values[i]=values[i+1];
            values[i+1] = temp;
        }

冒泡排序的优化算法：

import java.util.Arrays;
public class Test1 {
    public static void main(String[] args) {
        int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
    }
    public static void bubbleSort(int[] values) {
        int temp=0;
        int i;
        // 外层循环：n个元素排序，则至多需要n-1趟循环
        for (i = 0; i < values.length - 1; i++) {
            // 定义一个布尔类型的变量，标记数组是否已达到有序状态
            boolean flag = true;
    /*内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后*/
            for (int j = 0; j < values.length - 1 - i; j++) {
                // 如果前一个元素大于后一个元素，则交换两元素的值；
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                       //本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
                    flag = false;
                }
            }
           //根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
            if (flag) {
                break;
            }
        }
    }
}

9：二分法检索（折半检索）

        

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] arr = { 30,20,50,10,80,9,7,12,100,40,8};
        int searchWord = 20; // 所要查找的数
        Arrays.sort(arr); //二分法查找之前，一定要对数组元素排序
        System.out.println(Arrays.toString(arr));
        System.out.println(searchWord+"元素的索引："+binarySearch(arr,searchWord));
    }
 
    public static int binarySearch(int[] array, int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int middle = (low + high) / 2;
            if(value == array[middle]){
                return middle;         //返回查询到的索引位置
            }
            if(value > array[middle]){
                low = middle + 1;
            }
            if(value < array[middle]){
                high = middle - 1;
            }
        }
        return -1;     //上面循环完毕，说明未找到，返回-1
    }
}-