尚硅谷Java——宋红康笔记【day6-day10】

2023-08-20 12:42:10

day6

一、数组的概述

1.数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念：

数组名

元素

角标、下标、索引

数组的长度：元素的个数

3.数组的特点：

1）数组是有序排列的

2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型

3）创建数组对象会在内存中开辟一整块连续的空间
4）数组的长度一旦确定，就不能修改。

4.数组的分类：
① 按照维数：一维数组、二维数组、。。。
② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

5.一维数组的使用
① 一维数组的声明和初始化

② 如何调用数组的指定位置的元素

③ 如何获取数组的长度

④ 如何遍历数组

ArrayTest.java

public class ArrayTest {

public static void main(String[] args) {

    //1. 一维数组的声明和初始化

    int num;//声明

    num = 10;//初始化

    int id = 1001;//声明 + 初始化

    int[] ids;//声明

    //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行

    ids = new int[]{1001,1002,1003,1004};

    //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行

    String[] names = new String[5];

    //错误的写法：


//      int[] arr1 = new int[];


//      int[5] arr2 = new int[5];


//      int[] arr3 = new int[3]{1,2,3};


    //也是正确的写法：

    int[] arr4 = {1,2,3,4,5};//类型推断

    //总结：数组一旦初始化完成，其长度就确定了。

    //2.如何调用数组的指定位置的元素:通过角标的方式调用。

    //数组的角标（或索引）从0开始的，到数组的长度-1结束。

    names[0] = "王铭";

    names[1] = "王赫";

    names[2] = "*";

    names[3] = "孙居龙";

    names[4] = "王宏志";//charAt(0)


//      names[5] = "周扬";


    //3.如何获取数组的长度。

    //属性:length

    System.out.println(names.length);//5

    System.out.println(ids.length);

    //4.如何遍历数组

    /*System.out.println(names[0]);

    System.out.println(names[1]);

    System.out.println(names[2]);

    System.out.println(names[3]);

    System.out.println(names[4]);*/

    for(int i = 0;i < names.length;i++){

        System.out.println(names[i]);

    }

}




}

⑤ 数组元素的默认初始化值

数组元素是整型：0

数组元素是浮点型：0.0

数组元素是char型：0或'\u0000'，而非'0'

数组元素是boolean型：false

数组元素是引用数据类型：null

⑥ 数组的内存解析

public class ArrayTest1 {

public static void main(String[] args) {

    //5.数组元素的默认初始化值

    int[] arr = new int[4];

    for(int i = 0;i < arr.length;i++){

        System.out.println(arr[i]);

    }

    System.out.println("**********");

    short[] arr1 = new short[4];

    for(int i = 0;i < arr1.length;i++){

        System.out.println(arr1[i]);

    }

    System.out.println("**********");

    float[] arr2 = new float[5];

    for(int i = 0;i < arr2.length;i++){

        System.out.println(arr2[i]);

    }

    System.out.println("**********");

    char[] arr3 = new char[4];

    for(int i = 0;i < arr3.length;i++){

        System.out.println("----" + arr3[i] + "****");

    }

    if(arr3[0] == 0){

        System.out.println("你好！");

    }

    System.out.println("**********");

    boolean[] arr4 = new boolean[5];

    System.out.println(arr4[0]);

    System.out.println("**********");

    String[] arr5 = new String[5];

    System.out.println(arr5[0]);

    if(arr5[0] == null){

        System.out.println("北京天气不错！");

    }

}




}

二维数组的使用

1.理解：对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

2.二维数组的使用:

① 二维数组的声明和初始化

② 如何调用数组的指定位置的元素

③ 如何获取数组的长度

④ 如何遍历数组

public class ArrayTest2 {

    public static void main(String[] args) {

        //1.二维数组的声明和初始化

        int[] arr = new int[]{1,2,3};//一维数组

        //静态初始化

        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};

        //动态初始化1

        String[][] arr2 = new String[3][2];

        //动态初始化2

        String[][] arr3 = new String[3][];

        //错误的情况

//      String[][] arr4 = new String[][4];

//      String[4][3] arr5 = new String[][];

//      int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

    //也是正确的写法：

    int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};

    int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

    //2.如何调用数组的指定位置的元素

    System.out.println(arr1[0][1]);//2

    System.out.println(arr2[1][1]);//null

    arr3[1] = new String[4];

    System.out.println(arr3[1][0]);

    //3.获取数组的长度

    System.out.println(arr4.length);//3

    System.out.println(arr4[0].length);//3

    System.out.println(arr4[1].length);//4

    //4.如何遍历二维数组

    for(int i = 0;i < arr4.length;i++){

        for(int j = 0;j < arr4[i].length;j++){

            System.out.print(arr4[i][j] + "  ");

        }

        System.out.println();

    }

}




}

规定：二维数组分为外层数组的元素，内层数组的元素

int[][] arr = new int[4][3];

外层元素：arr[0],arr[1]等

内层元素：arr[0][0],arr[1][2]等

⑤ 数组元素的默认初始化值

针对于初始化方式一：比如：int[][] arr = new int[4][3];

外层元素的初始化值为：地址值

内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：int[][] arr = new int[4][];

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，否则报错。

⑥ 数组的内存解析

public class ArrayTest3 {

    public static void main(String[] args) {

    int[][] arr = new int[4][3];

    System.out.println(arr[0]);//[I@15db9742

    System.out.println(arr[0][0]);//0


//      System.out.println(arr);//[[I@6d06d69c


    System.out.println("*****************");

    float[][] arr1 = new float[4][3];

    System.out.println(arr1[0]);//地址值

    System.out.println(arr1[0][0]);//0.0

    System.out.println("*****************");

    String[][] arr2 = new String[4][2];

    System.out.println(arr2[1]);//地址值

    System.out.println(arr2[1][1]);//null

    System.out.println("*****************");

    double[][] arr3 = new double[4][];

    System.out.println(arr3[1]);//null


//      System.out.println(arr3[1][0]);//报错


}




}

day7

java.util.Arrays

操作数组的工具类，里面定义了很多操作数组的方法

1.boolean equals(int[] a,int[] b):判断两个数组是否相等。

2.String toString(int[] a):输出数组信息。

3.void fill(int[] a,int val):将指定值填充到数组之中。

4.void sort(int[] a):对数组进行排序。

5.int binarySearch(int[] a,int key)

例子：

import java.util.Arrays;

public class ArraysTest {


public static void main(String[] args) {

    //1.boolean equals(int[] a,int[] b):判断两个数组是否相等。

    int[] arr1 = new int[]{1,2,3,4};

    int[] arr2 = new int[]{1,3,2,4};

    boolean isEquals = Arrays.equals(arr1, arr2);

    System.out.println(isEquals);

    //2.String toString(int[] a):输出数组信息。

    System.out.println(Arrays.toString(arr1));

    //3.void fill(int[] a,int val):将指定值填充到数组之中。

    Arrays.fill(arr1,10);

    System.out.println(Arrays.toString(arr1));

    //4.void sort(int[] a):对数组进行排序。

    Arrays.sort(arr2);

    System.out.println(Arrays.toString(arr2));

    //5.int binarySearch(int[] a,int key)

    int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

    int index = Arrays.binarySearch(arr3, 210);

    if(index >= 0){

        System.out.println(index);

    }else{

        System.out.println("未找到");

    }

}




}

数组的复制、反转、查找(线性查找、二分法查找）

public class ArrayTest2 {

public static void main(String[] args) {

    String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};

    //数组的复制(区别于数组变量的赋值：arr1 = arr)

    String[] arr1 = new String[arr.length];

    for(int i = 0;i < arr1.length;i++){

        arr1[i] = arr[i];

    }

    //数组的反转

    //方法一：


//      for(int i = 0;i < arr.length / 2;i++){


//          String temp = arr[i];


//          arr[i] = arr[arr.length - i -1];


//          arr[arr.length - i -1] = temp;


//      }


    //方法二：


//      for(int i = 0,j = arr.length - 1;i < j;i++,j--){


//          String temp = arr[i];


//          arr[i] = arr[j];


//          arr[j] = temp;


//      }


    //遍历

    for(int i = 0;i &lt; arr.length;i++){

        System.out.print(arr[i] + &quot;\t&quot;);

    }

    System.out.println();

    //查找（或搜索）

    //线性查找：

    String dest = &quot;BB&quot;;

    dest = &quot;CC&quot;;

    boolean isFlag = true;

    for(int i = 0;i &lt; arr.length;i++){

        if(dest.equals(arr[i])){

            System.out.println(&quot;找到了指定的元素，位置为：&quot; + i);

            isFlag = false;

            break;

        }

    }

    if(isFlag){

        System.out.println(&quot;很遗憾，没有找到的啦！&quot;);

    }

    //二分法查找：(熟悉)

    //前提：所要查找的数组必须有序。

    int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

    int dest1 = -34;

    dest1 = 35;

    int head = 0;//初始的首索引

    int end = arr2.length - 1;//初始的末索引

    boolean isFlag1 = true;

    while(head &lt;= end){

        int middle = (head + end)/2;

        if(dest1 == arr2[middle]){

            System.out.println(&quot;找到了指定的元素，位置为：&quot; + middle);

            isFlag1 = false;

            break;

        }else if(arr2[middle] &gt; dest1){

            end = middle - 1;

        }else{//arr2[middle] &lt; dest1

            head = middle + 1;

        }

    }

    if(isFlag1){

        System.out.println(&quot;很遗憾，没有找到的啦！&quot;);

    }

}




}

数组中的常见异常

1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetion

2.空指针异常：NullPointerException

快速排序

通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。

public class QuickSort {

    private static void swap(int[] data, int i, int j) {

        int temp = data[i];

        data[i] = data[j];

        data[j] = temp;

    }

private static void subSort(int[] data, int start, int end) {

    if (start &lt; end) {

        int base = data[start];

        int low = start;

        int high = end + 1;

        while (true) {

            while (low &lt; end &amp;&amp; data[++low] - base &lt;= 0)

                ;

            while (high &gt; start &amp;&amp; data[--high] - base &gt;= 0)

                ;

            if (low &lt; high) {

                swap(data, low, high);

            } else {

                break;

            }

        }

        swap(data, start, high);

        subSort(data, start, high - 1);//递归调用

        subSort(data, high + 1, end);

    }

}

public static void quickSort(int[] data){

    subSort(data,0,data.length-1);

}

public static void main(String[] args) {

    int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };

    System.out.println(&quot;排序之前：\n&quot; + java.util.Arrays.toString(data));

    quickSort(data);

    System.out.println(&quot;排序之后：\n&quot; + java.util.Arrays.toString(data));

}




}

数组的冒泡排序的实现

public class BubbleSortTest {

    public static void main(String[] args) {

    int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};

    //冒泡排序

    for(int i = 0;i &lt; arr.length - 1;i++){

        for(int j = 0;j &lt; arr.length - 1 - i;j++){

            if(arr[j] &gt; arr[j + 1]){

                int temp = arr[j];

                arr[j] = arr[j + 1];

                arr[j + 1] = temp;

            }

        }

    }

    for(int i = 0;i &lt; arr.length;i++){

        System.out.print(arr[i] + &quot;\t&quot;);

    }

}




}

day8

概述

一、Java面向对象学习的三条主线：（第4-6章）
1.Java类及类的成员：属性、方法、构造器；代码块、内部类

2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)

3.其它关键字：this、super、static、final、abstract、interface、package、import等

“大处着眼，小处着手”

二、“人把大象装进冰箱”

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

  • ① 把冰箱门打开
  • ② 抬起大象，塞进冰箱
  • ③ 把冰箱门关闭

2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

三、面向对象的两个要素：

类：对一类事物的描述，是抽象的、概念上的定义

对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

面向对象程序设计的重点是类的设计

设计类，就是设计类的成员。

类中方法的声明和使用

方法：描述类应该具有的功能。

比如：

Math类：sqrt()\random() ...

Scanner类：nextXxx() ...

Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...

1.举例：

public void eat(){}`

public void sleep(int hour){}`

public String getName(){}

public String getNation(String nation){}

2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
方法体
}

注意：static、final、abstract 来修饰的方法，后面再讲。

3.说明：

3.1 关于权限修饰符：默认方法的权限修饰符先都使用public

Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说

3.2 返回值类型： 有返回值 vs 没有返回值

3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

3.2.2 我们定义方法该不该有返回值？

① 题目要求

② 凭经验：具体问题具体分析

3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

3.4 形参列表： 方法可以声明0个，1个，或多个形参。

3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...

3.4.2 我们定义方法时，该不该定义形参？

① 题目要求

② 凭经验：具体问题具体分析

3.5 方法体：方法功能的体现。

4.return关键字的使用：

4.1使用范围：使用在方法体中

4.2.作用：① 结束方法
② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。

4.3.注意点：return关键字后面不可以声明执行语句。

5.方法的使用中，可以调用当前类的属性或方法

特殊的：方法A中又调用了方法A:递归方法。

方法中，不可以定义方法。

类中属性的使用

属性（成员变量） vs 局部变量

1.相同点：

1.1 定义变量的格式：数据类型 变量名 = 变量值

1.2 先声明，后使用

1.3 变量都有其对应的作用域

2.不同点：

2.1 在类中声明的位置的不同

属性：直接定义在类的一对{}内

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2 关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。

常用的权限修饰符：private、public、缺省、protected --->封装性

局部变量：不可以使用权限修饰符。

2.3 默认初始化值的情况：

属性：类的属性，根据其类型，都有默认初始化值。

整型（byte、short、int、long）：0

浮点型（float、double）：0.0

字符型（char）：0 （或'\u0000'）

布尔型（boolean）：false

引用数据类型（类、数组、接口）：null

局部变量：没有默认初始化值。

意味着，我们在调用局部变量之前，一定要显式赋值。

特别地：形参在调用时，我们赋值即可。

2.4 在内存中加载的位置：

属性：加载到堆空间中 （非static）

局部变量：加载到栈空间

类的其他说明

一、设计类，其实就是设计类的成员

属性 = 成员变量 = field = 域、字段

方法 = 成员方法 = 函数 = method

创建类的对象 = 类的实例化 = 实例化类

二、类和对象的使用（面向对象思想落地的实现）：

1.创建类，设计类的成员

//1.创建类，设计类的成员

class Person{

//属性

String name;

int age = 1;

boolean isMale;

//方法

public void eat(){

    System.out.println(&quot;人可以吃饭&quot;);

}

public void sleep(){

    System.out.println(&quot;人可以睡觉&quot;);

}

public void talk(String language){

    System.out.println(&quot;人可以说话,使用的是：&quot; + language);

}




}

2.创建类的对象

3.通过“对象.属性”或“对象.方法”调用对象的结构

三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

四、对象的内存解析

day9

万事万物皆对象

一、理解“万事万物皆对象”

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

Scanner,String等

文件：File

网络资源：URL

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

二、内存解析的说明

1.引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）

三、匿名对象的使用

1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象

2.特征：匿名对象只能调用一次。

3.使用：如下

public class InstanceTest {

    public static void main(String[] args) {

        Phone p = new Phone();

//      p = null;

        System.out.println(p);

    p.sendEmail();

    p.playGame();

    //匿名对象


//      new Phone().sendEmail();


//      new Phone().playGame();


    new Phone().price = 1999;

    new Phone().showPrice();//0.0

    //**********************************

    PhoneMall mall = new PhoneMall();


//      mall.show(p);


//匿名对象的使用


mall.show(new Phone());


}


}


class PhoneMall{


public void show(Phone phone){

    phone.sendEmail();

    phone.playGame();

}


}


class Phone{


double price;//价格


public void sendEmail(){

    System.out.println(&quot;发送邮件&quot;);

}

public void playGame(){

    System.out.println(&quot;玩游戏&quot;);

}

public void showPrice(){

    System.out.println(&quot;手机价格为：&quot; + price);

}




}

方法的重载（overload）

1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

"两同一不同":同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同

2.举例：
Arrays类中重载的sort() / binarySearch()

3.判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

4.在通过对象调用方法时，如何确定某一个指定的方法： 方法名 ---> 参数列表

可变个数形参的方法

1.jdk 5.0新增的内容

2.具体使用：

2.1 可变个数形参的格式：数据类型 ... 变量名

public void show(String ... strs)

2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。

2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。

2.5 可变个数形参在方法的形参中，必须声明在末尾

2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

关于变量的赋值：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

方法的形参的传递机制：值传递

1.形参：方法定义时，声明的小括号内的参数

实参：方法调用时，实际传递给形参的数据

2.值传递机制：如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

day10

面向对象的特征一：封装与隐藏 3W:what? why? how?

一、问题的引入：当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值

加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).

此时，针对于属性就体现了封装性。

二、封装性的体现：
我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ...

class Animal{

String name;

private int age;

private int legs;//腿的个数

//对属性的设置

public void setLegs(int l){

    if(l &gt;= 0 &amp;&amp; l % 2 == 0){

        legs = l;

    }else{

        legs = 0;

        //抛出一个异常（暂时没有讲）

    }

}

//对属性的获取

public int getLegs(){

    return legs;

}




}

三、封装性的体现，需要权限修饰符来配合。

1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public

2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类的话，只能使用：缺省、public

  • 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

四种访问权限修饰符

Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限

修饰符 类内部 同一个包 不同包的子类 同一个工程
private Yes
（缺省） Yes Yes
protected Yes Yes Yes
public Yes Yes Yes Yes

对于class的权限修饰只可以用public和default（缺省）

public类可以在任意地方被访问

default类只可以被同一个包内部的类访问

构造器

一、构造器的作用：

1.创建对象

2.初始化对象的信息

二、说明：

1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器

2.定义构造器的格式：权限修饰符 类名(形参列表){}

3.一个类中定义的多个构造器，彼此构成重载

4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

5.一个类中，至少会有一个构造器。

总结：属性赋值的先后顺序

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

JaveBean

JavaBean是一种Java语言写成的可重用组件。

所谓JavaBean，是指符合如下标准的Java类：

类是公共的

有一个无参的公共的构造器

有属性，且有对应的get、set方法

this关键字的使用

1.this可以用来修饰、调用：属性、方法、构造器

2.this修饰属性和方法：

this理解为：当前对象 或 当前正在创建的对象

2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this调用构造器

① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器

② 构造器中不能通过"this(形参列表)"方式调用自己

③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"

④ 规定："this(形参列表)"必须声明在当前构造器的首行

⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

package和import

一、package关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念

2.使用package声明类或接口所属的包，声明在源文件的首行

3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

4.每"."一次，就代表一层文件目录。

补充：同一个包下，不能命名同名的接口、类。不同的包下，可以命名同名的接口、类。

二、import关键字的使用

import:导入

1.在源文件中显式的使用import结构导入指定包下的类、接口

2.声明在包的声明和类的声明之间

3.如果需要导入多个结构，则并列写出即可

4.可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构

5.如果使用的类或接口是java.lang包下定义的，则可以省略import结构

6.如果使用的类或接口是本包下定义的，则可以省略import结构

7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。

8.使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入

9.import static:导入指定类或接口中的静态结构:属性或方法。

MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层、控制器层与数据模型层。这种将程序输入输出、数据处理以及数据的展示分离开来的设计模式使程序结构变得灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

模型层：model 主要处理数据

数据对象封装 model.bean/domain

数据库操作类 model.dao

数据库 model.db

控制层：controller 处理业务逻辑

应用界面相关 controller.activity

存放fragment controller.fragment

显示列表的适配器 controller.adapter

服务相关的 controller.service

抽取的基类controller.base

视图层：view 显示数据

相关工具类 view.utils
自定义 viwe.ui

JDK中主要的包介绍

java.lang ------ 包含一些Java语言的核心类，如String、Math、Integer、System、Thread，提供常用功能

java.net ------ 包含执行与网络相关的操作的类和接口

java.io ------ 包含能够提供多种输入/输出功能的类

java.util ------ 包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数

java.text ------ 包含了一些java格式化相关的类

java.sql ------ 包含了java进行JDBC数据库编程的相关类/接口

java.awt ------ 包含了构成抽象窗口工具集（abstract window toolkits)的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）

上一篇：hdu A Magic Lamp


下一篇：Java相关英语单词