Java培训总结-第2周

在本周的学习中，主要学习的是Java的数组、类和方法的应用以及面向对象的基本概念，在学习的过程中，主要是类和方法的应用比较抽象，理解起来比较困难。

下面是本周学习内容目录

数组

面向对象

类和方法

一、数组

所谓数组就是有限个类型相同的变量的集合。

1.数组的声明

数组的元素类型必须相同，不能存在多种数据类型。初始化了数组长度后，数组长度不能改变。数组有以下两种种声明方式。

//第一种，先定义数组长度，在赋值给各个元素。
int[] a = new int[3];
a[0] = 0;
a[1] = 1;
a[2] = 2;
//第二种，直接赋值，数组长度就是元素个数。
int[] a = {0,1,2};

不管程序有没有显示的初始化，Java 虚拟机都会先自动给它初始化为默认值。

整数类型（byte、short、int、long）的基本类型变量的默认值为0。

单精度浮点型（float）的基本类型变量的默认值为0.0f。

双精度浮点型（double）的基本类型变量的默认值为0.0d。

字符型（char）的基本类型变量的默认为 “/u0000”。

布尔性的基本类型变量的默认值为 false。

引用类型的变量是默认值为 null。

数组引用类型的变量的默认值为 null。当数组变量的实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。

数组例子：

1) int[] a; //声明,没有初始化默认值是null

2) int[] a=new int[5]; //初始化为默认值,int型为0

2.数组的排序

冒泡排序：

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一 点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public static void Sort(int a[])
{
//排序，从a[0]开始排，从小到大
for (i = 0; i < a.length; i++)
{
for (j = i + 1; j < a.length; j++)
{
if (a[i] > a[j])
{
a[i]= a[i] ^ a[j];
a[j]= a[i] ^ a[j];
a[i]= a[i] ^ a[j];
}
}
}
//将十个数输出
for (i = 0; i < 10; i++)
printf("%d\n", a[i]);
}

选择排序：

它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）

public static void Sort(int a[])
{
//从第一个位置开始
for (int i = 0; i < a.length - 1; i++)
{
int index = i;
//寻找最小的数据索引
for (int j = i + 1; j < a.length; j++)
if (a[j] < a[index])
index = j;
//如果最小数位置变化则交换
if (index != i)
a[index]= a[index] ^ a[j];
a[j]= a[index] ^ a[j];
a[index]= a[index] ^ a[j]; ;
}
}

2.数组元素的查找

顺序查找：

核心：从数据的第一个元素开始，依次比较，直到找到目标数据或查找失败。

1.从表中的第一个元素开始，依次与关键字比较。

2.若某个元素匹配关键字，则 查找成功。

3.若查找到最后一个元素还未匹配关键字，则 查找失败。

顺序查找对表中元素的排序无要求，这些元素在表中可以任意排序，这使得顺序查找的适应性很高。顺序查找的实现很简单，其示例代码如下：

public static int binSearch(int a[], int key, int index) {
if (a[index] =  key) {
return index;
} else {
binSearch(a[], key, index + 1)
}
}

二分查找法：

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好，占用系统内存较少；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

采用非递归方式完成二分查找法:

public static int binSearch(int a[], int key) {
int mid;
int start = 0;
int end = a.length - 1;
while (start <= end) {
mid = (end - start) / 2 + start;
if (key < a[mid]) {
end = mid - 1;
} else if (key > a[mid]) {
start = mid + 1;
} else {
return mid;
}
}
return -1;
}

采用递归方式完成二分查找算法:

public static int binSearch(int a[], int start, int end, int key) {
int mid = (end - start) / 2 + start;
if (a[mid] == key) {
return mid;
}
if (start >= end) {
return -1;
} else if (key > a[mid]) {
return binSearch(a, mid + 1, end, key);
} else if (key < a[mid]) {
return binSearch(a, start, mid - 1, key);
}
return -1;
}

二、面向对象

面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术[1] 发展到一定阶段后的产物。

1.面向对象的基本概念

官方的语言很抽象，我们把官方的解释和定义抛开。想想，自己有什么，对！！我们自己有手脚眼口鼻等一系列的器官。来把自己所具有的器官就可以看作我们的属性，自己是不是可以喜怒哀乐和嬉笑怒骂，这些是不是我们的行为，那么自己的具有的属性加自己有的行为就称为一个对象。

注意！！我们自己，一个个体是一个对象，因为，你是你，我是我，我们虽然有相同的，但是我们不一样，比如你比我高，我比你头发长。

接下来在进一步。我和你都是人，因为我和你有相似的东西，所以我和你都属于人类。人类，就是人的总称，也是相似对象的一种抽象。

从上面看：我和你只是人类的两个特列，但是外星人也可以用人类来称呼我们，看的出来：类的具体表现或者实例就是对象，而对象的抽象或者总概括就是类。

2.面向对象的三个基本特征是：封装、继承、多态

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø 实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

三、类和方法

在Java中定义类，使用关键字class完成，语法如下：

class 类名称 {
属性 (变量) ;
行为 (方法) ;
}

class Name {     // 类名称首字母大写
String name ;
int age ;
public void tell() {        // 没有static
System.out.println("姓名：" + name + "，年龄：" + age) ;
}
}

类定义完成之后，肯定无法直接使用。如果要使用，必须依靠对象，那么由于类属于引用数据类型，所以对象的产生格式（两种格式）如下：

（1）格式一：声明并实例化对象

类名称 对象名称 = new 类名称 () ;

（2）格式二：先声明对象，然后实例化对象：

类名称 对象名称 = null ;
对象名称 = new 类名称 () ;

引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。

当一个实例化对象产生之后，可以按照如下的方式进行类的操作：

对象.属性：表示调用类之中的属性；

对象.方法()：表示调用类之中的方法。

范例：使用对象操作类

class Name {
private String name;
private int age;

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 String toString() {
return "test [name=" + name + ", age=" + age + "]";
}
}

public class TestDemo {
public static void main(String args[]) {
Name per = new Name() ;// 声明并实例化对象
per.name = "张三" ;//操作属性内容
per.age = 30 ;//操作属性内容
per.get() ;//调用类中的get()方法
}
}