Java系列（三）__Java面向对象（1）

1、方法的定义及使用

        方法是一段可以被重复调用的代码块，利用方法可以对一些重复使用的功能进行包装，并且统一维护。但是在Java之中对于方法有一些关键性的问题今天还不能够解决，所以今天给出的方法只是一个基础模式，而且只能够在主类中定义，由主方法直接调用。而这样方法的定义结构如下：

public static 返回值类型 方法名称([数据类型 参数名称 , ...]) {          [return [返回值] ;] }

         对于方法的返回值类型主要是以之前讲解的数据类型划分中的类型为主，如果现在某一个不需要返回内容，那么就使用void表示。

范例：定义一个没有参数，并且没有返回值的方法

public class TestDemo {          public static void main(String args[]) {                    printMessage() ;  // 由主方法直接调用                    printMessage() ;  // 由主方法直接调用                    printMessage() ;  // 由主方法直接调用          }          public static void printMessage() {                    System.out.println("Hello World .") ;          } }

         可以发现此时方法名称采用第一个单词字母小写，而后每一个单词首字母大写的形式编写。

         方法定义完成之后可以利用方法名称进行多次的调用，但是现在暂时不要过多的考虑什么时候使用方法，在工作之中定义方法只有一个原则：“如果你发现某些代码总是在不断的重复复制和粘贴的话，那么就要考虑将其定义为方法”。

范例：定义一个有返回值的方法

public class TestDemo {          public static void main(String args[]) {                    System.out.println(echo("小顾同学")) ;                    System.out.println(echo("小雪同学")) ;          }          public static String echo(String name) {                    return "ECHO : " + name ;          } }

         参数可以定义多个，多个参数之间可以使用“,”进行分割。

范例：定义一个加法操作

public class TestDemo {          public static void main(String args[]) {                    System.out.println(add(10,20)) ;                    int temp = add(100,200) ;                    System.out.println(temp) ;          }          public static int add(int x, int y) {                    return x + y ;          } }

         以上是方法基本的使用形式，但是在进行方法操作的时候还有一个小的注意点：如果一个方法使用了void定义，那么可以利用return来结束方法调用。

范例：使用return结束方法调用

public class TestDemo {          public static void main(String args[]) {                    fun(3) ;                    fun(5) ;          }          public static void fun(int x) {                    if (x == 3) {                             return ;       // 之后的代码不执行了                    }                    System.out.println("x = " + x) ;          } }

         方法之中使用return和在循环之中使用break、continue道理是一样的，都需要经过if语句的判断。

1.1、方法重载（Overload）

         在具体的应用重载概念之前，首先来根据之前的方式做一个简单程序，现在要求定义三个方法，这三个方法都是加法操作，可以实现两个整数、三个整数、两个小数的相加操作。所以现在编写出了以下的代码。

范例：实现功能

public class TestDemo {          public static void main(String args[]) {                    System.out.println(add1(10,20)) ;                    System.out.println(add2(10,20,30)) ;                    System.out.println(add3(10.2,30.5)) ;          }          public static int add1(int x,int y) {                    return x + y ;          }          public static int add2(int x,int y,int z){                    return x + y + z ;          }          public static double add3(double x,double y) {                    return x + y ;          } }

         此时已经成功的实现了操作，但是也可以发现一些问题：最大的问题在于每一个方法上都要进行一些标号。而且每个不同的方法名称后面跟的参数也不同，这样在使用的时候就非常的麻烦了。所以如果说现在一些方法拥有同类功能，往往可以将其定义为一个名字，而一旦多个方法是一个名字，那么这种形式就被称为方法的重载。

         方法重载：方法名称相同、参数的类型及个数不同。

范例：实现方法重载

public class TestDemo {          public static void main(String args[]) {                    System.out.println(add(10,20)) ;                    System.out.println(add(10,20,30)) ;                    System.out.println(add(10.2,30.5)) ;          }          public static int add(int x,int y) {                    return x + y ;          }          public static int add(int x,int y,int z){                    return x + y + z ;          }          public static double add(double x,double y) {                    return x + y ;          }}

         调用方法的时候虽然是同一个方法名称，但是却会根据参数的类型及个数不同，执行不同的方法体。那么这样定义形式在调用方法的时候会显得非常的方便。

提示：关于方法重载时返回值类型问题

         方法重载的概念之中，并没有针对于方法的返回值类型是否统一有明确的要求，但是从实际的效果来看，一般方法重载时，返回值类型最好相同。这一点是属于人为的开发标准规定，而不是语法规定。

范例：观察以下程序

public class TestDemo {          public static void main(String args[]) {                    System.out.println("HELLO") ;                    System.out.println(10) ;                    System.out.println(10.2) ;                    System.out.println('A') ;                    System.out.println(true) ;          }}

         发现“System.out.println()”可以输出所有的数据类型，则得出的结论：“此方法被重载过了”。

1.2、方法递归调用（了解）

         如果要想研究递归，请将本部分的代码写300遍以上，其意自现。

         所谓的方法递归，指的一个方法自己调用自己的形式。但是在进行递归调用的时候一定要设置好结束条件。而且每一次递归调用的时候都一定要修改递归条件。

范例：实现一个1 ~ 100的累加 —— 使用while循环实现

public class TestDemo {          public static void main(String args[]) {                    int x = 1 ;                    int sum = 0 ;                    while(x <= 100) {        // sum += x ++ ;                             sum += x ;                             x ++ ;                    }                    System.out.println(sum) ;          } }

范例：利用递归实现，要求可以实现任意数据的累加操作

         · 既然可以实现任意数据，那么所有的数据可以采用减法的形式，到1结束。

public class TestDemo {          public static void main(String args[]) {                    System.out.println(sum(100)) ;          }          public static int sum(int data){    // 递归是针对于方法调用                    if(data == 1) {    // 已经计算到最后一个了                             return 1 ;                    }                    return data + sum(data - 1) ;          } } // 第一次调用sum()（由主方法调用）：return 100 + sum(99)； // 第二次调用sum()（自身调用）：return 99 + sum(98)； // 第三次调用sum()（自身调用）：return 98 + sum(97)； // 倒数第二次调用sum()（自身调用）：return 2 + sum(1)； // 倒数第一次调用sum()（自身调用）：return 1； // 最终：return 100 + 99 + 98 + ... + 3 + 2 + 1；

范例：现在有五个人围坐在一起，第一个人问第二个人说他多大了，第二个人说比第一个人小2岁，，于是第二个人又问第三个人，第三个人说比第二个人小2岁，依次类推，问到第五个人的时候，他说自己20岁，那么请问第一个人多大岁数？

         现在既然有五个人，而且也有一定的规律，那么同时也知道了第五个人岁数，就可以把第五个人作为结束条件。

public class TestDemo {          public static void main(String args[]) {                    System.out.println(age(1)) ;          }          public static int age(int num) {                    if(num == 5) {                             return 20 ;                    }                    return 2 + age(num + 1);          } }

         递归实际上和循环是如出一辙的，但是递归可以承办更加复杂的逻辑操作，但是如果你本身就没写习惯递归操作，则可以放弃了。

         在开发之中有一个明确的准则：尽量不要去使用递归操作，因为有可能造成内存溢出。

2、类与对象

2.1、类与对象的基本概念

         在整个面向对象编程之中，类与对象是两个最基础的单元，所有的特征必须通过类和对象来体现，那么下面首先来区分一下这两者的区别：

                   · 类：是具备某些共同的特征群体，属于广义的范畴；

                   · 对象：是类的具体描述，实际的产物，例如：一个具体的人一定是对象；

         在实际的工作之中一定要首先定义出类，类规定了所有可以使用的操作行为，而后再根据类产生对象，一个类可以同时产生多个对象。对象的所有行为都受到类的控制，例如：小刁同学一定是一个对象，但是他所有的行为都应该是人类的行为，例如：他可以跑步、可以唱歌、可以跳舞，也可以从高楼上做自由落体运动，但是他绝对依靠自己无法飞行，无法在火里待着。

         类本身规定了对象的行为，而在类之中有两个重要的组成部分：

                   · 属性：是标识每一个对象的特征，每一个对象都有自己的属性内容，所谓的属性实际上就是一个变量；

                   · 方法：是公共的行为，表示某些固定的操作，例如：说话。

         在Java之中可以使用class来定义一个类。

范例：定义一个表示人信息的简单类

class Person {     // 定义类，类名称首字母大写          String name ;       // 定义属性，表示姓名          int age ;      // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } }

         在这个类之中包含有两个属性（name、age）和一个方法（tell()），但是如果单独有类是不可以被使用的，所有的类都一定要通过对象产生后才可以使用，在Java之中类是属于引用数据类型，如果是引用数据类型，则对象的定义格式：

                   · 声明并实例化对象：类名称 对象名称 = new 类名称()；

                   · 分步进行：

                            |- 声明对象：类名称 对象名称 = null；

                            |- 实例化对象：对象名称 = new 类名称()。

         所有的引用数据类型，如果要想进行使用，那么必须通过关键字“new”来进行内存的分配操作（开辟内存）。

         当一个类产生了实例化对象之后，就可以通过如下的两种方式进行类的简单操作：

                   · “对象.属性”：表示要访问类之中的属性内容；

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

范例：通过对象操作类

class Person {     // 定义类，类名称首字母大写          String name ;     // 定义属性，表示姓名          int age ;     // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person per = new Person() ;        // 声明并实例化对象                    per.name = "张三" ;  // 调用类中的name属性赋值                    per.age = 20 ;               // 调用类中的age属性赋值                    per.tell() ;          } }

         如果在一个类对象产生之后没有设置属性的内容。那么所有对象之中的属性内容都是其对应数据类型的默认值。

         在之前已经解释过了关于基本数据类型的操作，但是类本身是属于引用类型，如果是引用就要牵扯到内存关系，那么为了方便进行内存关系的解释，下面将采用C++之中的内存分析方法分析以上程序，首先对于常用内存主要有两块：

· 栈内存：每一块栈内存保存的是一块堆内存的引用地址，可以理解为堆内存的名字，在程序之中可以简单的利用对象名称来理解栈内存功能；

· 堆内存：保存每一个对象的具体信息，是真正的数据体，但是堆内存必须通过关键字new才可以开辟，以后不管何种情况下，只要是存在有new永恒表示开辟新的堆内存空间；

 

         现在可以非常清楚栈内存和堆内存之间的关系以及作用了，那么下面再使用另外一种方式进行对象的实例化操作。

范例：分步完成操作

class Person {     // 定义类，类名称首字母大写          String name ;       // 定义属性，表示姓名          int age ;      // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person per = null ;                 // 声明对象                    per = new Person() ;     // 实例化对象                    per.name = "张三" ;      // 调用类中的name属性赋值                    per.age = 20 ;                // 调用类中的age属性赋值                    per.tell() ;          } }

         在日后进行程序编写的时候，对于对象实例化也有可能要通过判断得来，例如：现在某对象实例化，但是要根据判断的结果进行不同类型的对象实例化，所以就必须有一个对象的声明。

         但是在使用这类语法操作的时候也会存在一个隐患：

public class TestDemo {          public static void main(String args[]) {                    Person per = null ;               // 声明对象                    per.name = "张三" ;      // 调用类中的name属性赋值                    per.age = 20 ;                // 调用类中的age属性赋值                    per.tell() ;          } }

         本程序之中只存在有声明对象，但是却没有实例化对象，没有关键字new就表示没有堆内存开辟。那么此时，如果进行对象操作的话（对象调用属性或者是对象调用方法）会出现“NullPointerException”（空指向异常）异常信息，此异常一直都会陪伴你们，而且一定要记住，出现此类异常只会在引用数据类型上出现，在进行错误排查的时候要根据提示的行数进行修正。

         以后在讲解之中，如果说的是实例化对象表示的就是已经有堆内存空间开辟的对象。

2.2、初步深入

         对于引用数据类型可以说是整个Java的灵魂所在，初学者最容易在此处犯迷糊，那么下面将通过几个简单的程序来进行引用数据的分析操作。

范例：定义两个对象，观察内存分配

class Person {     // 定义类，类名称首字母大写          String name ;       // 定义属性，表示姓名          int age ;      // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person perA = new Person() ;        // 实例化对象                    Person perB = new Person() ;        // 实例化对象                    perA.name = "张三" ;                    perA.age = 20 ;                    perB.name = "李四" ;                    perB.age = 30 ;                    perA.tell() ;                    perB.tell() ;          } }

         本程序声明并实例化了两个Person对象，而且由于存在有两个关键字new，那么一定表示将开辟两块堆内存空间，那么各自的堆内存空间都由各自的对象完成，所以这两个对象之间不会受到相互的影响。

范例：进行内存分配

class Person {     // 定义类，类名称首字母大写          String name ;       // 定义属性，表示姓名          int age ;      // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person perA = new Person() ;         // 实例化对象                    Person perB = null ;     // 声明对象                    perA.name = "张三" ;                    perA.age = 20 ;                    perB = perA ;                    perB.name = "李四" ;                    perA.tell() ;          } }

         在程序之中，每一个对象的堆内存空间都是有自己空间的编码的，而栈保存的应该是空间地址（地址编码，数值）那么在进行对象引用传递的时候，就跟int型数据一样，交换的只是数值数据。

范例：继续观察引用传递

class Person {     // 定义类，类名称首字母大写          String name ;       // 定义属性，表示姓名          int age ;      // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person perA = new Person() ;         // 实例化对象                    Person perB = new Person() ;         // 实例化对象                    perA.name = "张三" ;                    perA.age = 20 ;                   perB.name = "李四" ;                    perB.age = 30 ;                    perB = perA ;                    perB.name = "王五" ;                    perA.tell() ;          } }

         每一个int型数据只能够保存一个数据，如果现在修改了int型数据的内容，那么原始的内容一定会小时，同理，每一块栈内存就类似于int变量，只能够保存一块堆内存空间的地址，如果现在要求其保存另外的堆内存空间地址，那么原始的空间地址将无法被继续保留。

         在Java之中，如果某一块堆内存空间不再有任何的栈内存所指向，那么这块堆内存空间就将称为垃圾，所有的垃圾空间都要等待被GC（垃圾收集器，Garbage Collector）不定期进行回收与释放。

         所以一定要记住，在任何的程序开发过程之中，都一定以减少垃圾空间产生为开发的根本原则。

3、封装性

封装是面向对象之中第一大主要特征，其主要的意义在于类内部的操作对外部不可见。

范例：观察一下原始操作的问题

class Person {     // 定义类，类名称首字母大写          String name ;       // 定义属性，表示姓名          int age ;      // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person per = new Person() ;                    per.name = "张三" ;                    per.age = -20 ;                    per.tell() ;          } }

         这个时候代码没有任何的错误，只能够证明没有语法错误，但是现在是属于业务逻辑出错。在以后的工作之中，所有的人面对的都是业务逻辑的错误。而造成此错误的关键因素在于，属性对外可操作。那么一旦对外可以操作，就表示存在有安全隐患。那么要想解决这些安全隐患首先要解决的就是对外不可见。现在就可以使用private关键字来定义属性。

范例：使用private定义属性

class Person {     // 定义类，类名称首字母大写          private String name ;   // 定义属性，表示姓名          private int age ;   // 定义属性，表示年龄          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person per = new Person() ;                    per.name = "张三" ;  // 错误: name可以在Person中访问private                    per.age = -20 ;    // 错误: age可以在Person中访问private                    per.tell() ;          } }

         此时的错误提示信息应该这样翻译：name属性因为private声明，所以只能够在Person类之中访问，那么就证明private声明的属性，此属性只能够在本类中访问。但是再安全不能对外操作，也是没用的，所以一般对于private属性而言，如果要进行操作往往都需要编写setter、getter方法。以private String name为例：

                   · setter：public void setName(String n)，所有的检查操作一定要在设置上完成；

                   · getter：public String getName()；

范例：编写setter、getter

class Person {     // 定义类，类名称首字母大写          private String name ;     // 定义属性，表示姓名          private int age ;    // 定义属性，表示年龄          public void setName(String n) {                    name = n ;          }          public void setAge(int a) {                    if (a >= 0 && a <= 250) {                             age = a ;                    }        // 如果不满足条件，age属性内容就是0          }          public String getName() {                    return name ;          }          public int getAge() {                    return age ;          }          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person per = new Person() ;                    per.setName("张三") ;  // 通过setter间接操作属性                    per.setAge(-20) ;           // 通过setter间接操作属性                    per.tell() ;          } }

         以上的检测严格来讲并不标准，但是对于现在理解private是有帮助。

         开发原则：以后只要是类之中的属性不需要思考永恒都要使用private封装，封装之后的属性一定要编写setter、getter方法设置和取得。

4、构造方法

在讲解构造方法之前，首先来研究一下对象的实例化格式：

                   · ①类名称 ②对象名称 = ③new ④类名称()，那么每一个组成部分都有自己的作用：

                            |- “①类名称”：主要是用来表示对象的类型；

                            |- “②对象名称”：相当于是一个变量，用于标记对象的操作；

                            |- “③new”：表示开辟一个新的堆内存空间；

                            |- “④类名称()”：实际上这个调用的就是构造方法。

         构造方法的定义：构造方法的名称要与类名称保持一致，而且构造方法没有返回值类型的声明。

范例：定义构造方法

class Person {     // 定义类，类名称首字母大写          public Person() {         // 方法名称与类名称相同                    System.out.println("*****************") ;          } } public class TestJava {          public static void main(String args[]) {                    Person per = null ;        // 声明对象                    per = new Person() ;   // 实例化对象          } }

         构造方法是在类之中进行的定义，并且是在使用关键字new为对象实例化的时候默认进行的调用。

         在本程序之中定义的是一个没有参数的构造方法，所以在实例化对象的时候也没有传递任何参数，但是如果定义的是一个有参数的构造方法，则要在对象实例化的时候传递指定的参数。

范例：定义有参数的构造方法

class Person {     // 定义类，类名称首字母大写          public Person(String n) {       // 方法名称与类名称相同                    System.out.println("***************** n = " + n) ;          } } public class TestJava {          public static void main(String args[]) {                    Person per = null ;        // 声明对象                    per = new Person("HELLO") ;       // 实例化对象          } }

         现在针对于构造方法进行一些说明：

1、   在一个类之中，如果没有明确的进行构造法方法的定义，那么会在程序编译时，自动的生成一个无参的，什么都不做的构造方法，以Person类为例，生成的构造方法如下：

public Person() {          }

         但是如果此时类之中已经明确的定义了构造方法的话，则此默认构造方法将不会被自动生成。即：类之中至少会提供有一个无参构造方法。

2、   在类之中定义的构造方法只有在使用关键字new实例化新对象的时候调用一次，而普通方法是在实例化对象产生之后调用多次的。

         疑问：为什么构造方法定义的时候既然没有返回值，为什么void声明？

         构造方法的调用时机很普通方法是不同的，但是普通方法的定义标准：

public 返回值类型 方法名称()

         那么既然调用时机不同，电脑如何去区分普通方法和构造方法呢？依靠方法名称明显是不可能的，它只能够依靠定义结构，所以如果构造方法上写上了void，就成普通方法了，系统是无法分辨的。

3、   构造方法允许进行重载，但是构造方法重载的时候只需要注重参数的类型及个数的不同即可，因为构造方法的名称永恒和类名称保持一致。

范例：构造方法重载

class Person {     // 定义类，类名称首字母大写          private String name ;     // 定义属性，表示姓名          private int age ;    // 定义属性，表示年龄          public Person() {}          public Person(String n) {                    setName(n) ;        // 调用本类方法          }          public Person(String n,int a) {                    setName(n) ;        // 调用本类方法                    setAge(a) ; // 调用本类方法          }          public void setName(String n) {                    name = n ;          }          public void setAge(int a) {                    if (a >= 0 && a <= 250) {                             age = a ;                    }       // 如果不满足条件，age属性内容就是0          }          public String getName() {                    return name ;          }          public int getAge() {                    return age ;          }          // 此时的方法不是在主类中定义，并且不会由主方法直接调用          public void tell() {                    System.out.println("姓名：" + name + "，年龄：" + age) ;          } } public class TestDemo {          public static void main(String args[]) {                    Person per = new Person("张三",-30) ;                    per.tell() ;          } }

         通过以上的代码可以发现，构造方法的最大作用，在对象实例化的时候可以自动的传入一些要操作的数据，或者是执行某些固定的处理。可以通过构造方法完成，但是在此时也可以发现，如果现在要调用的是本类之中的其它方法，只需要直接编写方法名称即可，所以这个时候也可以采用更严格的方式处理：“如果现在调用的是本类方法，那么可以在方法前加上一个this关键字，使用this.方法()的形式调用”。

范例：严格的处理方式

public Person(String n,int a) {                    this.setName(n) ;          // 调用本类方法                    this.setAge(a) ;   // 调用本类方法          }

         提示：如果一个类之中定义了多个构造方法，那么这多个构造方法一定要注意顺序，建议按照参数的多少进行排序。

4、   【以后验证】对象的构造过程实际上它是多个行为的体现，例如：对象需要开辟空间，开辟空间之后需要为属性设置空间，而后空间分配完成之后，才轮到构造方法使用，留给用户最后的操作。在构造方法执行的时候所有的内存空间都已经分配成功了，同时都已经为属性设置完内容了。

class Person {     // 定义类，类名称首字母大写          private String name = "无名氏" ;          public Person() { // 方法名称与类名称相同                    // 构造方法是整个构造的最后一步，留给用户操作的                   System.out.println(name) ;     // 此时name属性已经分配完空间和默认值了          } } public class TestJava {          public static void main(String args[]) {                    Person per = null ;        // 声明对象                    per = new Person() ;     // 实例化对象          } }

         但是如果在构造没有执行前（构造方法是构造的最后一步），那么类之中的属性不会为其设置用户定义的默认值。所有的属性只能够是其对应数据类型的默认值，当然，这一块的内容暂时无法观察到。

5、匿名对象

在之前所使用的全部都是有名对象，例如发现对象的实例化格式：

                   · 类名称 对象 = new 类名称()；

         对象的名字保存在栈内存之中，而每调用对象名称的时候实际上调用的都是堆内存的操作，所以堆内存是对象真正有用的部分，那么所谓的匿名对象就是指开辟了堆内存空间，但是没有栈内存指向的对象。

范例：使用匿名对象

public class TestDemo {          public static void main(String args[]) {                    new Person("张三",-30).tell() ;          } }

         但是由于匿名对象不会有任何的栈内存所指向，所以只能够使用一次，一次之后就将成为垃圾，并且等待被GC释放。

6、第一个代码模型：简单Java类

所谓的简单Java类指的是类的组成结构单一，只包含了最基本的属性与属性的设置和取得功能。并且在日后的所有开发之中都是基于简单Java类的应用，那么本次首先给出简单Java类开发的基本原则：

                   · 类名称必须有意义，并且可以明确的表示出某一类事物，例如：学生、工人、狗、光盘；

                   · 类之中的所有属性必须使用private封装，而且所有的属性必须编写相应的setter、getter方法；

                   · 类之中可以定义多个构造方法，但是不管有多少个请一定要保证有一个无参构造方法；

                   · 类中不允许直接输出，即：不可以编写任何的“System.out.println()”语句，所有的输出要返回给被调用处；

                   · 类中需要编写一个可以取得对象完整信息的方法，此处暂时定义为getInfo()，返回值为String。

思考题：现在要求定义一个表示雇员的类，类之中包含有雇员的编号、姓名、职位、基本工资、佣金。

class Emp {         // 类名称可以直接反应群体特征          private int empno ;          private String ename ;          private String job ;          private double sal ;          private double comm ;          public Emp() {}  // 无参构造必须始终编写          public Emp(int eno,String ena,String j,double s,double c) {                    this.setEmpno(eno) ;                    this.setEname(ena) ;                   this.setJob(j) ;                    this.setSal(s) ;                    this.setComm(c) ;          }          public void setEmpno(int eno) {                    empno = eno ;          }          public void setEname(String ena) {                    ename = ena ;          }          public void setJob(String j) {                    job = j ;          }          public void setSal(double s) {                    sal = s ;          }          public void setComm(double c) {                    comm = c ;          }          public int getEmpno() {                    return empno ;          }          public String getEname() {                    return ename ;          }          public String getJob() {                    return job ;          }          public double getSal() {                    return sal ;          }          public double getComm() {                    return comm ;          }          public String getInfo() {                    return         "雇员信息：" + "\n" +                                      "\t|- 雇员编号：" + empno + "\n" +                                      "\t|- 雇员姓名：" + this.getEname() + "\n" +                                      "\t|- 雇员职位：" + this.getJob() + "\n" +                                      "\t|- 雇员工资：" + this.getSal() + "\n" +                                      "\t|- 雇员佣金：" + this.getComm() ;          } }

         此时一个表示雇员信息的简单Java类就定义完成了。

范例：测试程序

public class TestJava {          public static void main(String args[]) {                    System.out.println(new Emp(7369,"SMITH","CLERK",800.0,0.0).getInfo()) ;          } }

思考题：要求编写一个表示部门信息的类（部门编号、名称、位置）

class Dept {          private int deptno ;          private String dname ;          private String loc ;          public Dept() {}          public Dept(int dno,String dna,String l) {                    deptno = dno ;                    dname = dna ;                    loc = l ;          }          public void setDeptno(int dno) {                    deptno = dno ;          }          public void setDname(String dna) {                    dname = dna ;          }          public void setLoc(String l) {                    loc = l ;          }          public int getDeptno() {                    return deptno ;          }          public String getDname() {                    return dname ;          }          public String getLoc() {                    return loc ;          }          public String getInfo() {                    return "部门名称：" + deptno + "，名称：" + dname + "，位置：" + loc ;          } } public class TestJava {          public static void main(String args[]) {                    System.out.println(new Dept(10,"ACCOUNTING","New York").getInfo()) ;          } }

         这样的程序是今天必须要掌握的，而且每个人要求可以无障碍编写。