Java 读书笔记1

对象导论

1.类和类型实际上是同义的，整型，浮点型其实也是一种类；且対象定义方式都一样；

1
2
int a;             //整型
Test test1;        //Test类

2.刚刚傻了，居然在想子类是否可以拥有自己的方法、、、、而且还试了一下代码。当然可以了啊！但是再想想的话，其实父类能做的事一定小于等于子类所做的事情，子类相对父类可以进行扩展； uml设计模式中：子类可以出现在父类出现的任何地方也是这个原因，因为父类能做的所有事，子类都可以做；

3.单根继承,我们知道java所有类最终都继承自Object类，这样所有类其实都是一个类型，这样就保证所有对象都具有某些功能，包括基本操作，在堆上创建，参数传递，以及垃圾回收；

4.java不允许多继承，你不能有俩父亲，但是你可以有爷爷，有太爷爷；

5.容器和参数化类型；
容器呢，是一个可以容纳对象的器皿；在程序中，由于需要多少对象不确定，容器的大小就也不一定喽；
那么假如容器什么都接受，在存放的时候，java一定会将其转化为Object；那么在拿出的时候就会存在向下转型这个问题了；Android经常会有；
那么如果我们只想存放一种，就可以使用参数化类型；定好了能存猴子，就不能存猪；

辗转相除法

1

由于实在记不得辗转相除法的原理，所以只能自己写一下 记录一下啦；
https://zh.wikipedia.org/wiki/%E8%BC%BE%E8%BD%89%E7%9B%B8%E9%99%A4%E6%B3%95

两个整数的最大公约数是能够同时整除它们的最大的正整数。辗转相除法基于如下原理：两个整数的最大公约数等于其中较小的数和两数的差的最大公约数。例如，252和105的最大公约数是21（252 = 21 × 12；105 = 21 × 5）；因为252 − 105 = 21 × (12 − 5) = 147，所以147和105的最大公约数也是21。在这个过程中，较大的数缩小了，所以继续进行同样的计算可以不断缩小这两个数直至其中一个变成零。这时，所剩下的还没有变成零的数就是两数的最大公约数。由辗转相除法也可以推出，两数的最大公约数可以用两数的整数倍相加来表示，如21 = 5 × 105 + (−2) × 252。这个重要的结论叫做裴蜀定理。

简单来说呢就是两个公约数
1：两个数的最大公约数

2：两个数中其中小的那个数，和两个数差值 的最大公约数

这两个公约数是相等的；

所以我们可以让其一直减小；

本来呢是得到差值，但是两个数如果差距比较大，就变为求余运算啦；

回溯法-素数环问题

1：问题描述

一个环由一圈整数组成，要求是相邻的两个整数之和为素数；

2：问题思考

对于回溯法来说，我们深度优先，也就是说的想法就是先找到一个能够全部填完的环；
1：如果填入一个数是成立的，我们就继续填写下一个位置，如果这个数不成立，我们就换下一个数填写，相当于我们剪掉了这个数的树枝，去寻找下一个；

2：填写最后一个数时，应该考虑其应该和第一个数之和是素数；

3：acm要求：

http://acm.cugb.edu.cn/problem_show.php?pid=1789

4：代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
import java.util.ArrayList;
import java.util.Scanner;
/**
 * Created by asus on 2016/12/23.
 */
public class PrimeCircle {
    int n ;
//    boolean flag = true;
    public  static  void  main(String arg[])
    {
        PrimeCircle primeCircle = new PrimeCircle();
        Scanner cin = new Scanner(System.in);
        ArrayList list = new ArrayList();
        int i = 0;
        while(cin.hasNextInt()) {
            list.add( cin.nextInt());
            i++;
        }
        for (i=0;i<list.size();i++)
        {
            System.out.println("Case "+(i+1)+":");
            primeCircle.PrimeCircle((int)list.get(i));
            if(i!=list.size()-1)System.out.println();
        }
    }
    void  PrimeCircle(int n)    //输入为n，素数环从1到n；
    {
        if (n==1) {                 //防止输入为一，其实没有意义啦；
            System.out.println(1);
            return;
        }
        int i ,k ;
        this.n = n;
        int a[] = new int[n];
        for ( i =0; i <n ;i++)      //初始化数组a，用来储存素数环答案
        {
            a[i]=0;
        }
        a[0]= 1 ; k =1;             //指定第一个位置为1；凡事总有开头的嘛
            while (k>=1)
            {
                a[k] = a[k] +1;
                while (a[k]<=n) {
                    if (Check(k, a) == 1)  //如果满足要求，就跳出
                        break;
                    else
                        a[k] = a[k] + 1;       //不满足，就试验下一个数
                }
                if (a[k]<= n &&k==n-1)          //如果最后一个也成立，就输出啦
                {
                    for (i=0;i<n-1 ;i++)
                    System.out.print(a[i]+" ");
                    System.out.print(a[n-1]);           //这样写会在最后输出换行，而不是空格
                    System.out.println();
                }
                if (a[k]<=n && k <n - 1)                //如果没有完成，就继续下一个位置
                    k+=1;
                else
                    a[k--]=0;                           //说明这个树枝无法填写了，所以回到父节点；
            }
    }
    int Prime( int x)       //判断素数，素数返回1，合数返回0；
    {
        int i , n ;
        n = (int) Math.sqrt(x);
        for (  i = 2 ; i <=n ; i++)
        {
            if (x%i==0)
                return 0;
        }
        return 1;
    }
    int Check (int k,int a[])
    {
        int flag = 0 ;
        for (int i =0;i<k;i++)          //检查是否重复
            if (a[i] == a[k])
                return  0;
        flag = Prime(a[k]+a[k-1]);  //检验与相邻之和是否是素数
        if (flag ==1&&k ==n-1)          //如果是最后一个，需要检查与开始值得和
            flag = Prime(a[k]+a[0]);
        return flag;
    }
}

归并排序 --分治初探

先上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class MergeSort {					//差不多照书敲得
    private  int[] myarray = new int[10];
    public int[] getMyarray() {
        return myarray2;
    }
    private  int [] myarray2;
    public MergeSort() {
    }
    public void  MergeSort(int array[], int start, int end) {
        int mid;
        if (start == end)
            return;
        else {
            mid = (start + end) / 2;
            MergeSort(array, start, mid);
            MergeSort(array, mid + 1, end);
            Merge(array, myarray,start,mid,end);
            for (int i = start; i <= end; i++) {
               array[i]= myarray[i];
            }
        }
        myarray2 = array;
    }
    void Merge(int array[], int r1[], int start, int mid, int end)//归并
    {
        int first = start, second =mid+1, k =start ;
	    while (first<=mid && second <=end)          
        {
            if (array[first]<= array[second])
                r1[k++] = array[first++];
            else
                r1[k++] = array[second++];
        }
        while (first<=mid)
        {
            r1[k++]= array[first++];
        }
        while (second<=end)
        {
            r1[k++]= array[second++];
        }
    }
}

more >>

IntelliJ IDEA 与junit

1

软件测试要来一个测试大作业，要用junit，在学习java的一年以后，再见过android studio 这种现代化IDE以后，我可是受不了jcreator 这种东西啦；

所以让我们来使用IntelliJ IDEA 吧；虽说有点大材小用，但还是好用啊；你可以先去官网看看，如果和你胃口的话，跟着我做吧；
https://www.jetbrains.com/idea/

more >>

继续跑<br><br>带着赤子的骄傲