本文主要是介绍JavaSE基础--尚硅谷视频笔记02，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Day06

数组的概述

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

    数组名
    元素
    角标、下标、索引
    数组的长度：元素的个数

• 数组的特点：
  ①数组是有序排列的
  ②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
  ③创建数组对象会在内存中开辟一整块连续的空间 4）数组的长度一旦确定，就不能修改
• 数组的分类： ① 按照维数：一维数组、二维数组、。。。 ② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
• 一维数组的使用
  ①一维数组的声明和初始化
  ②如何调用数组的指定位置的元素
  ③如何获取数组的长度
  ④如何遍历数组

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
        //声明一个数组
        int[] num;
        //静态初始化,数组的初始化和数组元素的赋值操作同时进行
        num=new int[]{1,2,3,4,5};//等价于int []num=new int[]{1,2,3,4,5}
        System.out.println(Arrays.toString(num));
        //动态初始化:数组的初始化和数组元素和赋值操作分开进行
        int[] nums=new int[5];
        for(int i=0;i<nums.length;++i){//nums.length可以获取nums数组的长度
            nums[i]=i+6;
        }
        System.out.println(Arrays.toString(nums));
        
        //下面这种写法也是正确的
        int [] arr={1,2,3,4,5};
        System.out.println(Arrays.toString(arr));
    }
}

输出：

[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]
[1, 2, 3, 4, 5]

• 数组元素的默认初始化值
  ①数组元素是整型：0
  ②数组元素是浮点型：0.0
  ③数组元素是char型：0或’\u0000’，而非’0’
  ④数组元素是boolean型：false
  ⑤数组元素是引用数据类型：null
• 数组的内存解析

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
        //默认初始化
        int []arr=new int[4];
        float[]arr1=new float[4];
        String[] str=new String[4];
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(str));

        //人为赋值
        for (int i=0;i<arr.length;++i){
            arr[i]=i;
        }
        for (int i=0;i<arr.length;++i){
            arr1[i]=i*0.1f;
        }
        for (int i=0;i<arr.length;++i){
            str[i]=""+i;
        }
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(str));
    }
}

输出：

[0, 0, 0, 0]
[0.0, 0.0, 0.0, 0.0]
[null, null, null, null]
[0, 1, 2, 3]
[0.0, 0.1, 0.2, 0.3]
[0, 1, 2, 3]

二维数组的使用

• 理解：对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。
• 二维数组的使用:
  ①二维数组的声明和初始化
  ②如何调用数组的指定位置的元素
  ③如何获取数组的长度
  ④如何遍历数组

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
        //静态初始化
        int[][]arr=new int[][]{{1,2,3},{3,4},{2,5,4}};
        //动态初始化1
        int[][]arr2=new int[3][3];
        //动态初始化2
        int[][]arr3=new int[3][];

        //以下也是正确写法
        int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};   
    }
}

规定：二维数组分为外层数组的元素，内层数组的元素
⑤数组元素的默认初始化值
针对于初始化方式一：比如：int[][] arr = new int[4][3];

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

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

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

Day07

Java.util.Arrays

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

• boolean equals(int[] a,int[] b):判断两个数组是否相等。
• String toString(int[] a):输出数组信息。
• void fill(int[] a,int val):将指定值填充到数组之中。
• void fill(int[] a,int val):将指定值填充到数组之中。
• int binarySearch(int[] a,int key)
  关于这部分内容可以参考专门写的Arrays类常用方法：
  Arrays多个常用方法

数组中常见的异常

• 数组角标越界异常：ArrayIndexOutOfBoundsExcetion
• 空指针异常：NullPointerException

Day08

概述

• Java面向对象学习的三条主线：
  ①Java类及类的成员：属性、方法、构造器；代码块、内部类。
  ②面向对象的三大特征：封装性、继承性、多态性、(抽象性)
  ③其它关键字：this、super、static、final、abstract、interface、package、import等

“大处着眼，小处着手”

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

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

面向对象的两个要素：

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

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

    面向对象程序设计的重点是类的设计
    设计类，就是设计类的成员。

类中方法的声明和使用

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

    Math类：sqrt()\random() ...
    Scanner类：nextXxx() ...
    Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...

方法的声明：权限修饰符 返回值类型 方法名(形参列表){ 方法体 }
注意：static、final、abstract 来修饰的方法，后面再讲。

关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说

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

我们定义方法该不该有返回值？
① 题目要求
② 凭经验：具体问题具体分析

方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
形参列表：方法可以声明0个，1个，或多个形参。
方法体：方法功能的体现。

类中属性的使用

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

相同点：
定义变量的格式：数据类型 变量名 = 变量值
先声明，后使用
变量都有其对应的作用域 
不同点：
在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

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

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

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

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

    整型（byte、short、int、long）：0
    浮点型（float、double）：0.0
    字符型（char）：0 （或'\u0000'）
    布尔型（boolean）：false
    引用数据类型（类、数组、接口）：null
    局部变量：没有默认初始化值。(需要显示初始化)

意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。

在内存中加载的位置：

属性：加载到堆空间中 （非static）
局部变量：加载到栈空间

类的其他说明

设计类，其实就是设计类的成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

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

创建类，设计类的成员

public class Person {
    private  String name;
    private int age;
    private boolean isMale;
    
    public void eat(){
        System.out.println("人要吃饭");
    }
    public void sleep(){
        System.out.println("人要睡觉");
    }
    public void talk(String language){
        System.out.println("人可以说话，使用的是"+language+"语言");
    }
    public String getName() {
        return name;
    }
}

创建类的对象

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

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

Day09

万事万物皆对象

• 理解“万事万物皆对象”
  ①在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

    Scanner,String等
    文件：File
    网络资源：URL

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

• 内存解析的说明

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

• 匿名对象的使用
  ①理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
  ②特征：匿名对象只能调用一次，一次性用品。
  ③使用：如下

public class InstanceTest {
    public static void main(String[] args) {
        new PhoneMail().Show(new Phone1());//使用匿名的PhoneMail和匿名的Phone1对象，来调用PhoneMail里面的show方法
    }
}

class PhoneMail{
    public void Show(Phone1 phone1){
        phone1.sendMail();
        phone1.showPrice();
    }
}

class Phone1{
    double price;

    public void sendMail(){
        System.out.println("发送邮件");
    }
    public void playGame(){
        System.out.println("打游戏");
    }
    public void showPrice(){
        System.out.println("手机价格为:"+price);
    }
}

输出

发送邮件
手机价格为:0.0

方法的重载（overload）

• 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
  “两同一不同”:同一个类、相同方法名
  参数列表不同：参数个数不同，参数类型不同
• 例如：Arrays类中重载的sort() / binarySearch()
• 判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
• 在通过对象调用方法时，如何确定某一个指定的方法： 方法名 —> 参数列表

可变个数形参的方法

• jdk 5.0新增的内容
• 可变个数形参的格式：数据类型 … 变量名

public void show(String ... strs)

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

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

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

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

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

关于变量的赋值：

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

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

• 形参：方法定义时，声明的小括号内的参数。实参：方法调用时，实际传递给形参的数据
• 值传递机制：如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值，Java中只有值传递。

Day10

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

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

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

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

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

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

public class Animal {
    private String name;
    private int age;
    private int legs;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getLegs() {
        return legs;
    }

    public void setLegs(int legs) {
        if(legs!=0&&legs%2==0){
            this.legs=legs;
        }
        else{
            legs=0;
            //抛出异常（暂时未讲）
        }
    }
}

• 封装性的体现，需要权限修饰符来配合。
  ①Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
  ②4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
  ③具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

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

四种访问权限修饰符

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

    public类可以在任意地方被访问
    default类只可以被同一个包内部的类访问

构造器

• 构造器的作用：
  ①创建对象
  ②初始化对象的信息
• 说明
  ①如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
  ②定义构造器的格式：权限修饰符 类名(形参列表){}
  ③一个类中定义的多个构造器，彼此构成重载
  ④一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
  ⑤一个类中，至少会有一个构造器。
  总结：属性赋值的先后顺序
  ①默认初始化
  ②显式初始化
  ③构造器中初始化
  ④通过"对象.方法" 或 "对象.属性"的方式，赋值
  以上操作的先后顺序：① - ② - ③ - ④

JaveBean

JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：

    类是公共的
    有一个无参的公共的构造器
    有属性，且有对应的get、set方法

this关键字的使用

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

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

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

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

• this调用构造器

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

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

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

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

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

package和import

• package关键字的使用
  ①为了更好的实现项目中类的管理，提供包的概念

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

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

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

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

• import关键字的使用
  import:导入
  ①在源文件中显式的使用import结构导入指定包下的类、接口

②声明在包的声明和类的声明之间

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

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

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

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

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

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

⑨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）

以上内容主要参考了以下博客，在此感谢前辈的整理。自己主要承担搬运的任务，整理内容留作以后复习用。

https://www.cnblogs.com/kylinxxx/p/13165333.html

这篇关于JavaSE基础--尚硅谷视频笔记02的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！