java类的基础

类的概念：
将具有相同属性及相同行为的一组对象称为类。广义地讲，具有共同性质的事物的集合就称为类。
在面向对象程序设计中，类是一个独立的单位，它有一个类名，其内部包括成员变量，用于描述对象的属性；还包括类的成员方法，用于描述对象的行为。在Java 程序设计中，类被认为是一种抽象数据类型，这种数据类型，不但包括数据，还包括方法。这大大地扩充了数据类型的概念。
类是一个抽象的概念，要利用类的方式来解决问题，必须用类创建一个实例化的类对象，然后通过类对象去访问类的成员变量，去调用类的成员方法来实现程序的功能。这如同“汽车”本身是一个抽象的概念，只有使用了一辆具体的汽车，才能感受到汽车的功能。一个类可创建多个类对象，它们具有相同的属性模式，但可以具有不同的属性值。Java 程序为每一个类对象都开辟了内存空间，以便保存各自的属性值。

一、面向对象的程序设计有三个主要特征，如下：
封装性
继承性
多态性

1、封装性
封装是面向对象的方法所应遵循的一个重要原则。它有两个含义：一是指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位（即对象）中。另一层含义指“信息隐蔽”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知晓；或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节。
封装机制在程序设计中表现为，把描述对象属性的变量及实现对象功能的方法合在一起，定义为一个程序单位，并保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法。
封装机制的另一个特点是，为封装在一个整体内的变量及方法规定了不同级别的“可见性”或访问权限。
例:cal01+cal01Test

2、继承性
继承是面向对象方法中的重要概念，并且是提高软件开发效率的重要手段。
首先拥有反映事物一般特性的类，然后在其基础上派生出反映特殊事物的类。如已有的汽车的类，该类中描述了汽车的普遍属性和行为，进一步再产生轿车的类，轿车的类是继承于汽车类，轿车类不但拥有汽车类的全部属性和行为，还增加轿车特有的属性和行为。
在 Java 程序设计中，已有的类可以是 Java 开发环境所提供的一批最基本的程序——类库。用户开发的程序类是继承这些已有的类。这样，现在类所描述过的属性及行为，即已定义的变量和方法，在继承产生的类中完全可以使用。被继承的类称为父类或超类，而经继承产生的类称为子类或派生类。根据继承机制，派生类继承了超类的所有成员，并相应地增加了自己的一些新的成员。
面向对象程序设计中的继承机制，大大增强了程序代码的可复用性，提高了软件的开发效率，降低了程序产生错误的可能性，也为程序的修改扩充提供了便利。
若一个子类只允许继承一个父类，称为单继承；若允许继承多个父类，称为多继承。目前许多面向对象程序设计语言不支持多继承。而 Java 语言通过接口（interface）的方式来弥补由于 Java不支持多继承而带来的子类不能享用多个父类的成员的缺憾。
例：DS01+DP，Student+Person+ StudentTest，

3、类的多态性
多态是面向对象程序设计的又一个重要特征。多态是允许程序中出现重名现象。Java 语言中含有方法重载与成员覆盖两种形式的多态。
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。
例：MulTable，Exe+Exe01；

成员覆盖：子类与父类允许具有相同的变量名称，但数据类型不同，允许具有相同的方法名称，但完成的功能不同。
多态的特性使程序的抽象程度和简捷程度更高，有助于程序设计人员对程序的分组协同开发。

二、类与对象
面向对象的编程思想力图使在计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能地一致，类（class）和对象（object）就是面向对象方法的核心概念。类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的个体，因而也称实例（Instance）。
例：Calculator，panduanjiou，Person，Person2，Test01，Test02；

二、方法
方法可以简化程序的结构，也可以节省编写相同程序代码的时间，达到程序模块化的目的。
其实读者对方法应该不陌生，在每一个类里出现的 main()即是一个方法。使用方法来编写程序代码有相当多的好处，它可简化程序代码、精简重复的程序流程，并把具有特定功能的程序代码独立出来，使程序的维护成本降低。 方法可用如下的语法来定义：
格式：声明方法，并定义其内容

返回值类型 方法名称（类型 参数 1，类型 参数2，…）
{
程序语句 ；
return 表达式；
}
方法的主体

要特别注意的是，如果不需要传递参数到方法中，只要将括号写出，不必填入任何内容。此外，如果方法没有返回值，则 return 语句可以省略。

方法操作的示例 ：
在显示器上先输出 19 个星号“”，换行之后再输出“I Like Java！”这一字符串，最后再输出 19个星号。
01 // 以下程序主要说明如何去声明并使用一个方法
02 public class TestJava03
03 {
04 public static void main(String args[])
05 {
06 star(); // 调用 star() 方法
07 System.out.println(“I Like Java !”);
08 star(); //调用 star() 方法
09 }
10
11 public static void star() // star() 方法
12 {
13 for(int i=0;i<19;i++)
14 System.out.print(""); // 输出 19 个星号
15 System.out.print("\n"); // 换行
16 }
17 }

方法的参数与返回值
如果方法有返回值，则在声明方法之前就必须指定返回值的数据类型。相同的，
如果有参数要传递到方法内，则在方法的括号内必须填上该参数及其类型。 TestJava04
是用来说明方法的使用的另一个范例，它可以接收一个整数参数 n，输出 2n 个星号
后，返回整数 2n。

例：TestJava04
01 // 以下程序是关于方法的返回类型是整型的范例
02 public class TestJava04
03 {
04 public static void main(String args[])
05 {
06 int num;
07 num=star(7); // 输入 7给 star()，并以 num接收返回的数值　
08 System.out.println(num+" stars printed");
09 }
10
11 public static int star(int n) // star() method
12 {
13 for(int i=1;i<=2n;i++)
14 System.out.print(""); // 输出 2n 个星号
15 System.out.print("\n"); // 换行
16 return 2n; // 返回整数2*n
17 }
18 }

练习： TestJava04.java
01 // 以下的程序说明了方法的使用
02 public class TestJava04
03 {
04 public static void main(String args[])
05 {
06 double num;
07 num=show_length(22,19); // 输入22与19两个参数到show_length()里
08 System.out.println("对角线长度 = "+num);
09 }
10
11 public static double show_length(int m, int n)
12 {
13 return Math.sqrt(mm+nn); // 返回对角线长度　
14 }
15 }

方法的重载
方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或类型不同即可。在这种情况下，该方法就叫被重载了，这个过程称为方法的重载。
例：TestJava05.java
01 // 以下程序说明了方法的重载操作
02 public class TestJava05
03 {
04 public static void main(String[] args)
05 {
06 int int_sum ;
07 double double_sum ;
08 int_sum = add(3,5) ; // 调用有两个参数的 add 方法
09 System.out.println(“int_sum = add(3,5)的值是：”+int_sum);
10 int_sum = add(3,5,6) ; // 调用有三个参数的 add 方法
11 System.out.println(“int_sum = add(3,5,6)的值是：”+int_sum);
12 double_sum = add(3.2,6.5); // 传入的数值为 doule 类型
13 System.out.println(“double_sum = add(3.2,6.5)的值是：”+double_sum);
14 }
15 public static int add(int x,int y)
16 {
17 return x+y ;
18 }
19 public static int add(int x,int y,int z)
20 {
21 return x+y+z ;
22 }
23 public static double add(double x,double y)
24 {
25 return x+y ;
26 }
27 }

在整个 java 的面向对象程序设计中，this 是一个比较难理解的关键字，我们在刚开始上课时曾提到过，this 强调对象本身，那么什么是对象本身呢？其实在这里大家只要遵循一个原则就可以，就是 this 表示当前对象，而所谓的当前对象就是指调用类中方法或属性的那个对象。先来看一下面的程序片段：
class Person
{
private String name ;
private int age ;
public Person(String name,int age)
{
name = name ;
age = age ;
}
}
看上面的程序可以发现会有些问题，程序的本意是通过构造方法为 name 和 age进行初始化的，但是在构造方法中声明的两个参数的名称也同样是 name 和 age，这就造成了一种不清楚的关系，到底第7 行的形参name 是赋给了类中的属性 name，还是类中的属性 name 赋给了形参中的 name 呢？为了避免这种混淆的出现，可以采用 this这种方式，请看修改后的代码：
例：Person-1.java
1 class Person-1
2 {
3 private String name ;
4 private int age ;
5 public Person(String name,int age)
6 {
7 this.name = name ;
8 this.age = age ;
9 }
0 }
Person-1.java这段代码与Person.java的不同之处在于在第7、 8行分别加上了this关键字。还记得之前说过的 this 表示当前对象吗？那么此时的 this.name 和 this.age就分别代表类中的 name 与 age 属性，这个时候再完成赋值操作的话，就可以清楚的知道谁赋值给谁了。完整程序代码如下：
例：TestJavaThis.java
01 class Person
02 {
03 private String name ;
04 private int age ;
05 public Person(String name,int age)
06 {
07 this.name = name ;
08 this.age = age ;
09 }
10 public String talk()
11 {
12 return “我是：”+name+"，今年："+age+“岁” ;
13 }
14 }
15 public class TestJavaThis
16 {
17 public static void main(String[] args)
18 {
19 Person p = new Person(“张飞”,25) ;
20 System.out.println(p.talk()) ;
21 }
22 }
输出结果：
我是：张飞，今年：25岁