Java基础语法-第七节-面向对象上
面向过程和面向对象
- 面向过程：Procedure Oriented Programming(POP)强调的是功能行为，以函数为最小单位，考虑怎么做。
- 面向对象：Object Oriented Programming(OOP)将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
- 二者都是一种思想，面向对象是相对于面向过程而言的。
- 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
- 面向对象的三大特征:
- 封装 (Encapsulation)
- 继承 (Inheritance)
- 多态 (Polymorphism)
- 面向对象的思想概述
- 程序员从面向过程的执行者转化成了面向对象的指挥者
- 面向对象分析方法分析问题的思路和步骤：
- 根据问题需要，选择问题所针对的现实世界中的实体。
- 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
- 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
- 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
Java的基本元素：类和对象
-
面向对象的思想概述
- 类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
- “万事万物皆对象”
- 面向对象程序设计的重点是类的设计
- 类的设计，其实就是类的成员的设计
- 类(Class)和对象(Object)是面向对象的核心概念。
-
Java类及类的成员
- 现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。
- 现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java中用类class来描述事物也是如此。常见的类的成员有：
- 属 性：对应类中的成员变量。Field = 属性 = 成员变量
- 行 为：对应类中的成员方法。Method = (成员)方法 = 函数
//1.创建类，设计类的成员 class Person{ //属性 String name; int age = 1; boolean isMale; //构造器 public Person() {} public Person(String n,boolean im) { name = n; isMale = im; } //方法 public void eat() { System.out.println("人可以吃饭"); } public void sleep() { System.out.println("人可以睡觉"); } public void talk(String language) { System.out.println("人可以说话，语言为："+language); } //代码块 { name = "张三"; age = 17; isMale = true; } //内部类 class pet{ String name; float weight; } } -
类的语法格式
修饰符 class 类名{ 属性声明; 方法声明; } //说明：修饰符public:类可以被任意访问。类的正文要用{}括起来
对象的创建和使用
-
创建对象语法： 类名 对象名 = new 类名();
-
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）
//2.创建Person类的对象 Person person = new Person(); //调用对象的结构，属性，方法 //调用属性：“对象.属性” person.name = "Tom"; person.isMale = true; System.out.println(person.name); //调用方法：“对象.方法” person.eat(); person.sleep(); person.talk("Chinese"); -
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。
-
类的访问机制：
- 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。 （例外：static方法访问非static，编译不通过。）
- 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。
Person person2 = new Person(); System.out.println(person2.name);//null //*************************** Person person3 = person; System.out.println(person3.name);//Tom person3.age = 18; System.out.println(person.age);//18 -
内存解析
- 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
- 栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放。
- 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
-
匿名对象
- 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。如：new Person().shout();
- 使用情况
- 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
- 我们经常将匿名对象作为实参传递给一个方法调用
类的成员之一：属性
-
语法格式：修饰符 数据类型 属性名 = 初始化值 ;
- 说明1: 修饰符
- 常用的权限修饰符有：private、缺省、protected、public
- 其他修饰符：static、final (暂不考虑)
- 说明2：数据类型
- 任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
- 说明3：属性名
- 属于标识符，符合命名规则和规范即可。
//举例： public class Person{ private int age; //声明private变量 age public String name = “Lila”; //声明public变量 name } - 说明1: 修饰符
-
变量的分类：成员变量与局部变量
- 在方法体外，类体内声明的变量称为成员变量。
- 在方法体内部声明的变量称为局部变量。
- 注意：二者在初始化值方面的异同:
- 同：都有生命周期
- 异：局部变量除形参外，均需显式初始化。
- 成员变量（属性）和局部变量的区别
成员变量 局部变量 声明的位置 直接声明在类中 方法形参或内部，代码块内，构造器内等 修饰符 private,public,static,final等 不能用权限修饰符，可以用final修饰 初始化值 有默认初始化值 没有默认初始化值。必须显式赋值，方可使用 内存加载位置 堆空间或静态域内 栈空间 -
对象属性的默认初始化赋值：当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如同数组的默认初始化值相同。
类的成员之二：方法
-
什么是方法(method、函数):
- 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
- 将功能封装为方法的目的是，可以实现代码重用，简化代码
- Java里的方法不能独立存在，所有的方法必须定义在类里。
//举例： public class Person{ private int age; public int getAge() { //声明方法getAge() return age; } public void setAge(int i) { //声明方法setAge age = i; //将参数i的值赋给类的成员变量age } } -
方法的声明格式：
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛ 方法体程序代码 return 返回值; ｝- 说明1：修饰符：public,缺省,private, protected等
- 说明2：返回值类型：
- 没有返回值：void。
- 有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
- 说明3：方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
- 说明4：形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
- 说明5：返回值：方法在执行完毕后返还给调用它的程序的数据。
-
方法的分类：按照是否有形参及返回值
无返回值 有返回值 无形参 void 方法名（）{} 返回值的类型 方法名（）{} 有形参 void 方法名（形参列表）{} 返回值的类型 方法名（形参列表）{} -
方法的调用
- 方法通过方法名被调用，且只有被调用才会执行。
-
方法调用的过程分析
-
注 意：
- 方法被调用一次，就会执行一次
- 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
- 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
- 方法中只能调用方法或属性，不可以在方法内部定义方法
自定义Arrays工具类
public class ArraysUtil {
//求整型数组的最大值
public int getMax(int[] arr) {
int temp = arr[0];
for (int i = 1; i < arr.length; i++) {
if(temp < arr[i]) {
temp = arr[i];
}
}
return temp;
}
//求整型数组的最小值
public int getMin(int[] arr) {
int temp = arr[0];
for (int i = 1; i < arr.length; i++) {
if(temp > arr[i]) {
temp = arr[i];
}
}
return temp;
}
//求整型数组的总和
public int getSum(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
//求整型数组的平均值
public double getAvg(int[] arr) {
return (double)getSum(arr) / arr.length;
}
//反转数组
public void reverse(int[] arr) {
for(int i = 0,j = arr.length - 1;i < j;i++,j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//复制数组
public int[] copy(int[] arr) {
int[] arr2 = new int[arr.length];
for (int i = 0; i < arr2.length; i++) {
arr2[i]= arr[i];
}
return arr2;
}
//数组排序
public void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
boolean flag = true;
for (int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j]> arr[j + 1]) {
flag = false;
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if(flag) {
break;
}
}
}
//遍历数组
public void print(int[] arr) {
System.out.print("[ ");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
if(i!=arr.length-1) {
System.out.print(" , ");
}
}
System.out.println(" ]");
}
//查找指定元素
public int getIndex(int[] arr,int dest) {
for (int i = 0; i < arr.length; i++) {
if(arr[i] == dest) {
return i;
}
}
return -1;
}
}
方法的重载
-
概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
-
特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
-
示例：
//返回两个整数的和 int add(int x,int y){return x+y;} //返回三个整数的和 int add(int x,int y,int z){return x+y+z;} //返回两个小数的和 double add(double x,double y){return x+y;}
可变形参的方法
-
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量 public static void test(int a ,String[] books); //JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量 public static void test(int a ,String…books); -
说明：
- 声明格式：方法名(参数的类型名 ...参数名)
- 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
- 可变个数形参的方法与同名的方法之间，彼此构成重载
- 可变参数方法的使用与方法参数部分使用数组是一致的
- 方法的参数部分有可变形参，需要放在形参声明的最后
- 在一个方法的形参位置，最多只能声明一个可变个数形参
方法参数的值传递机制
- 方法，必须由其所在类或对象调用才有意义。若方法含有参数：
- 形参：方法声明时的参数
- 实参：方法调用时实际传给形参的参数值
- Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
- 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
- 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
递归方法
-
递归方法：一个方法体内调用它自身。
-
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
-
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
//求1~100的所有的数的和 System.out.println(getSum(100)); public int getSum(int n) { if(n <= 1) { return 1; }else { return n + getSum(n - 1); } }
OPP特征一：封装和隐藏
-
我们程序设计追求“高内聚，低耦合”。
- 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合 ：仅对外暴露少量的方法用于使用。
-
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
-
原因：使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。
-
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
- 隐藏一个类中不需要对外提供的实现细节；
- 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
- 便于修改，增强代码的可维护性；
类的成员之三：构造器
-
构造器的特征
- 它具有与类相同的名称
- 它不声明返回值类型。（与声明为void不同）
- 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
-
构造器的作用：创建对象；给对象进行初始化
- 如：Order o = new Order(); Person p =new Person(“Peter”,15);
- 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。
-
语法格式：
修饰符 类名 (参数列表) { 初始化语句； } -
根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供）
- 显式定义一个或多个构造器（无参、有参）
-
注 意：
- Java语言中，每个类都至少有一个构造器
-
默认构造器的修饰符与所属类的修饰符一致
- 一旦显式定义了构造器，则系统不再提供默认构造器
-
一个类可以创建多个重载的构造器
-
父类的构造器不可被子类继承
-
构造器重载
- 构造器一般用来创建对象的同时初始化对象。如
- 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象
- 构造器重载，参数列表必须不同
扩展
-
属性赋值过程：很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序。
-
赋值的位置：
① 默认初始化
-
② 显式初始化
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值
-
赋值的先后顺序：① - ② - ③ - ④
-
JavaBean
- JavaBean是一种Java语言写成的可重用组件。
- 所谓javaBean，是指符合如下标准的Java类：
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get、set方法
- 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
-
UML类图
- +表示 public 类型， - 表示 private 类型，#表示protected类型
- 方法的写法:方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型
关键字：this,import,package
this
- 在Java中，this关键字比较难理解，它的作用和其词义很接近。
- 它在方法内部使用，即这个方法所属对象的引用；
- 它在构造器内部使用，表示该构造器正在初始化的对象。
- this 可以调用类的属性、方法和构造器
- 什么时候使用this关键字呢？
- 当在方法内需要用到调用该方法的对象时，就用this。具体的：我们可以用this来区分属性和局部变量。比如：this.name =name;
- 使用this，调用属性、方法
- 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。
- 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
- 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
- this可以作为一个类中构造器相互调用的特殊格式
- 注意：
- 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
- 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
- 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"
- "this(形参列表)"必须声明在类的构造器的首行！
- 在类的一个构造器中，最多只能声明一个"this(形参列表)"
import
-
为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
-
语法格式：import 包名. 类名;
-
应用举例：
import pack1.pack2.Test; //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构 public class PackTest{ public static void main(String args[]){ Test t = new Test(); //Test类在pack1.pack2包中定义 t.display(); } } -
注意
- 在源文件中使用import显式的导入指定包下的类或接口
- 声明在包的声明和类的声明之间。
- 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
- 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
- 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
- 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
- import static组合的使用：调用指定类或接口下的静态的属性或方法
import static java.lang.System.*; public class Test1 { public static void main(String[] args) { out.println("hello"); } }
package
-
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。
- 它的格式为：package 顶层包名.子包名 ;
举例：pack1\pack2\PackageTest.java package pack1.pack2; //指定类PackageTest属于包pack1.pack2 public class PackageTest{ public void display(){ System.out.println("in method display()"); } } -
包对应于文件系统的目录，package语句中，用“.” 来指明包(目录)的层次；
-
包通常用小写单词标识。通常使用所在公司域名的倒置：com.baidu.xxx
-
源文件的布局：
-
包的作用：
- 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
- 包可以包含类和子包，划分项目层次，便于管理
- 解决类命名冲突的问题
- 控制访问权限
-
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)。
总结
/*
* 一，Java面向对象学习的三条主线(非官方)：
* 1.Java类及类的成员：属性，方法，构造器，代码块，内部类
* 2.面向对象的三大特征：封装性，继承性，多态性，(抽象性)
* 3.其他关键字：this,super,static,final,abstract,interface,import,package
* 目标：“大处着眼，小处着手”
* 二，面向对象和面向过程来实现“人把大象装进冰箱”
* 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
* ①把冰箱打开
* ②抬起大象，塞进冰箱
* ③把冰箱关闭
* 2.面向对象：强调具备功能的对象，以类/对象为最小基本单位，考虑谁来做
* 人{
* 打开(冰箱){
* 冰箱.开();
* }
* 抬起(大象){
* 大象.进入(冰箱);
* }
* 关闭(冰箱){
* 冰箱.关();
* }
* }
* 冰箱{
* 开(){}
* 关(){}
* }
* 大象{
* 进入(冰箱){}
* }
*三，面向对象的两个要素
* 类：对一类事物的描述，是抽象的，概念上的定义
* 对象：是实际存在的该类事物的每个个体，因而也成为实例(instance)
* >面向对象程序设计的重点是类的设计
* >类的设计，其实就是类的成员的设计
* "万物皆对象"的理解
* ①在Java语言范畴中，我们都将功能，结构等封装到类中，通过类的实例化，来调用具体的功能结构
* >Scanner,String等
* >文件：File
* >网络资源：URL
* ②涉及到Java语言与前端Html,后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类，对象。
*四，设计类，其实就是设计类的成员
* 属性 = 成员变量 = field = 域，字段
* 方法 = 成员方法 = 函数 = method
* 创建类的对象 = 类的实例化 = 实例化类
*五，类和对象的使用(面向对象思想落地的实现)
* 1.创建类，设计类的成员
* 2.创建类的对象
* 3.通过“对象.属性”或“对象.方法”调用对象的结构
*六，如果创建了一个类的多个对象，则每个对象都独立拥有一套类的属性。(非static的)
* 意味着：如果我们修改一个对象的属性，则不会影响另一个对象属性的值
*七，属性在类中的使用
*属性(成员变量)VS局部变量
* 相同点
* 定义变量的格式相同：数据类型 变量名 = 变量值
* 都是先声明后使用的
* 变量都有其对应的作用域
* 不同点
* 在类中声明的位置不同。
* 属性：直接定义在类的一对{}内
* 局部变量：声明在方法中，方法形参，代码块内，构造器形参，构造器内部的变量
* 关于权限修饰符的不同
* 属性：可以在声明属性时，指明其权限，使用权限修饰符
* 局部变量：不可以使用权限修饰符
* 默认初始化值的情况。
* 属性：类的属性，根据其类型都有默认初始化值
* 局部变量：没有默认初始化值，意味着，我们在调用局部变量之前，一定要显式赋值。特别的：形参在调用时赋值即可。
* 在内存中加载的位置不同
* 属性：加载到堆空间中 (非static)
* 局部变量：加载到栈空间
* 八，方法
* 方法：描述类应该具有的功能
* 1.举例
* public void eat(){}
* public void sleep(){}
* public String getName(){}
* public String setNation(String nation)()
* 2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* 注意：static,final,abstract等关键字也可以修饰方法
* 3.说明：
* 3.1权限修饰符：方法的默认修饰符是public
* Java规定的4种权限修饰符：private,public,缺省,protected
* 3.2返回值类型：有返回值 VS 没有返回值
* 如果方法有返回值，则必须在方法声明时指定返回值类型。同时方法中，
* 需要使用return关键字来返回指定类型的变量或常量：“return 数据;”
* 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不使用return,
* 但是，如果使用的话，只能“return ;”表示结束此方法的意思
* 3.3方法名：属于标识符，遵循标识符的命名规则，“见名知意”
* 3.4形参列表：方法可以声明0个，一个或多个形参。
* 格式：数据类型1 形参1，数据类型2 形参2 ...
* 3.5 方法体：方法功能的体现
* 4.return关键字的使用：
* 1.使用范围：使用在方法体中
* 2.作用：①结束方法 ②针对有返回值类型的方法，使用“return 数据”返回数据
* 3.注意：return关键字后面不可以声明执行语句
* 5.方法的使用：可以在方法中调用当前类的属性和方法。
* 注意：方法中不可以定义方法
* 6.方法的重载
* 1.定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可
* "两同一不同"：同一个类，相同方法名。参数列表不同
* 2.举例：Arrays类中重载的sort()和binarySearch()
* 3.判断是否是重载：跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系
* 4.在通过对象调用方法时，如何确定某一个指定的方法：方法名--->参数列表
* 7.可变个数形参的方法
* 1.jdk5.0以后新增的内容
* 2.具体使用
* 2.1 可变个数形参的格式：数据类型 ... 变量名
* 2.2 当调用可变个数形参的方法时，传入的参数个数可以是0个，1个，2个...
* 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同，形参也相同的数组之间不构成重载。换句话说二者不能一起出现
* 2.5 可变个数形参在方法的形参中，必须声明在末尾。
* 8.值传递机制
* 1.变量的赋值
* 如果变量是基本数据类型，此时赋值的是变量所保存的数据值
* 如果变量是引用数据类型，此时赋值是变量所保存的数据的地址值
* 2.方法的形参的传递机制：值传递
* 形参：方法定义时，声明的小括号内的参数
* 实参：方法调用时，实际传递给形参的数据
* 如果参数是基本数据类型，此时实参传递给形参的是实参真实存储的数据值
* 如果参数是引用数据类型，此时实参传递给形参的是实参存储数据的地址值
* 9.递归方法的使用(使用)
* 1.递归方法：一个方法体内调用它自身。
* 2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
* 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
*
* 九：补充：
* 内存解析的说明：引用类型的变量，只能存储两类值：null或地址值(含变量的类型)
* 匿名对象的使用
* ①理解：我们创建对象时，没有显示的赋给一个变量名。即匿名对象
* ②特征：匿名对象只能使用一次
* 十：面向对象的特征一：封装与继承
* 一：问题的引入：当我们创建一个对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。
* 这里，赋值操作要搜到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，
* 我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件
* 的添加。(比如setxxx()).同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。
* 则需要将其属性声明为私有的(private) -->此时，针对属性就体现了封装性
* 二：封装性的体现：
* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getxxx())和设置(setxxx())类都属性
* 扩展：封装性的体现：①如上 ②不对外暴露私有的方法 ③单例模式...
* 三：封装性的体现需要权限修饰符来配合。
* 1.Java规定的4种权限(从小到大排列)：private,缺省,protected,public
* 2.4种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类
* 3.具体的，修饰类的话只能使用： 缺省，public
* 总结封装性：Java提供了4种权限可以用来修饰类及类的内部结构，体现了类及类的内部结构在被调用时的可见性的大小
* 十一：类的结构之三：构造器(或构造方法，constructor)的使用
* 一：构造器的使用
* 创建对象 初始化对象的信息
* 二：说明：
* 1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
* 2.定义构造器的格式：权限修饰符 类名(形参列表){}
* 3.一个类中定义的多个构造器，彼此构成从重载
* 4.一旦我们显示的定义了类的构造器后，系统就不再提供默认的空参构造器
* 5.一个类中至少会有一个构造器
* 总结：属性赋值的先后顺序
* ①默认初始化
* ②显式初始化
* ③构造器初始化
*
* ④通过"对象.方法"或"对象.属性"的方式赋值
* 以后操作的先后顺序：① - ② - ③ - ④
* 十二：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关键字的使用
* 1.为了更好的实现项目中的类的管理，提供了包的概念
* 2.使用package声明类或接口所在的包，声明在源文件的首行
* 3.包，属于标识符，遵循标识符的命名规则，规范(xxxyyyzzz 全小写),“见名知意”
* 4.每“.”以此就代表一层文件目录
* 5.补充：同一个包下，不能命名同名的接口，类。不同的包下，可以命名同名的接口，类
* 十四：import关键字的使用
* 1.import意为导入
* 2.在源文件中显式的使用import结构导入指定包下的类，接口
* 3.声明在包的声明和类的声明之间
* 4.如果需要导入多个结构，则并列写出
* 5.可以使用“xxx.*”的方式，表示导入xxx包下的所有结构
* 6.如果使用的类或接口是java.lang包下定义的，则可以省略import结构
* 7.如果使用的类或接口是本包下定义的，则可以省略import结构
* 8.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
* 9.使用“xxx.*”的方式，可以表示导入xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显示导入
* 10.import static :表示导入指定类或接口中的静态结构：属性或方法
*/
