[零基础学JAVA]Java SE面向对象部分-07.面向对象基础（02）

上季内容回顾：

1、 类与对象的关系
2、 对象实例化之后才可以使用，如果使用了没有实例化（开辟了堆内存空间的）的对象则会出现NullPointerException。
3、 引用传递和垃圾的产生

 

本季目标

本季讲解了类的封装性的实现及JAVA EE中对封装属性的访问标准。又通过构造方法的概念详细讲解了对象实例化时的每一步操作及匿名对象的使用。

本季的知识点有：类的封装性、构造方法的使用和匿名对象。

 

类中方法的使用

一个类中肯定会有多个方法

class  {     String name;     int age;     void say ()     {         System.out.println("Hello");     }     void print()     {         say();     } } public class ooDemo01 {     public static void main (String args[])         Person p=new Person ();         p.print(); }

我们发现print()方法调用了say()方法，类中的方法确实可以相互调用哈~

class Person  {     String name;     int age;     void say ()     {         System.out.println("Hello");     }     void print()     {         //如果特别想表示是在本类中的方法，我们可以在前面加上this.         this.say();     } } public class ooDemo01 {     public static void main(String args[])     {         Person p=new Person();         p.print();     } }

程序执行效果一样哈~

我们看一下一个练习题哈，找出程序中的错误，并将错误改正哈~

对象没有被实例化就直接使用了，则肯定在运行的时候会出现错误 —— NullPointerException。

这样就OK了~~

封装

用我们上次类似的程序例子哈：

我们发现程序执行正常哈~

我们看下不加封装的时候程序的效果：

这个程序从语法上来说没有任何错误。可以我年龄不可以是-26哈~~造成这种笑话的根本原因在于属性对外部直接可见了。此时就只有加上封装进行操作。

一个属性前面加上了private则此属性对外部就不可见了。即：外部是不能直接访问的。

JAVA EE（J2EE）原则：对于封装的属性的设置和取得必须通过setter和getter方法，而且这两个方法也有自己的严格的命名要求。

//命名要求哈~ private String name; public void setName(String n) { name=n; } public String getName() { return name; }

我们通过setter和getter方法，两个值确实赋值上去了哈~ 但是不符合常理的值没有受到检查哈。

Setter是入口。Getter是出口，应该在setter方法处检查。而getter方法只是将值简单的返回。我们接着往下看哈~

我们发现年龄赋的-26判断为非法年龄了哈。

如果我们赋值年龄是正26呢？

OK,输出了正常的年龄哈，这就是加入封装后的好处哈~~~

加入封装之后，所有的操作都是通过方法的调用完成的。

构造方法

什么叫构造方法？
构造方法定义：构造方法是为类中的属性初始化的。

回顾：
对象产生的格式：类名称 对象名称 = new 类名称() ;

其中类名称() 就表示调用的构造方法

一个类在使用时肯定至少拥有一个构造方法，如果在类中没有声明构造方法，则肯定会自动生成一个无参的什么都不做的构造方法。

在这种情况下，程序会出错吗？我们验证一下哈~发现程序执行正常哈~效果一模一样，说明确实生成了这样一种构造方法。

构造方法的定义及使用

我们发现声明对象时，构造方法有没有被调用哈，执行效果说明没有被调用哈~

我们加一行代码p=new Person();将对象实例化

现在我们看下效果，确实构造方法被调用了

改进程序：
使用构造方法为类中的属性初始化。

我们验证一下：

我们发现一个错误找不到构造函数Person(),程序咋找无参的构造函数Person()，我们分析一下哈

我们发现上面我们定义了一个无参构造函数哈

回顾：
如果一个类中没有明确声明任何一个构造方法，则肯定自动生成一个无参的什么都不做的构造方法，相反如果一个类中已经明确的声明了一个构造方法，则不会再自动生成构造，也就是说一个类中至少保持有一个构造方法。

如果我们一定要使用Person p=new Person();我们可以在Person类中再定义一个无参的构造方法，现在Person类中有两个构造方法，其中参数的个数和类型不同，这种情况叫做构造方法的重载。

我们继续改进我们的程序哈，调用我们定义的构造方法

我们看下效果，和刚才的输出也是一模一样哈~

但是此程序中有一个缺陷，我们在定义时年龄给个-26哈：

程序执行下看一下效果：

 

程序提示非法年龄，为什么？因为我们在程序中定义了一个三目运算检测年龄赋值是否合法。但是我们所赋的年龄值-26有没在程序中进行运算？确实进行运算了哈，因为程序中age=a；已经进行赋值运算了哈~

所以说我们的构造方法中没有进行检测而让属性直接进行赋值了哈~而segAge()方法中有检测数据是否合法哈~

我们看下效果，的确年龄取值是-1了哈~

通过构造方法为属性初始化的时候，最好也经过setter方法完成。

构造方法的使用要求

匿名对象：只使用一次的对象。

new Person("王乾",26) 本身就是一个实例化对象，只是之前我们将这个对象给了一个对象名字。因为现在没有任何的对象名称指向它，所以使用一次之后就会等待被回收了。

匿名对象使用：有些时候需要为一些其他的类实例化的时候使用匿名对象。

下面我们做一个练习题哈，巩固一下所说的知识:

 程序代码：

class Employee
{
  //员工号
  private String empno;
  //姓名
  private String name;
  //薪水
  private float salary;
  //部门
  private String dept;
  //无参的构造方法一般都是写在第一个哈~~
  public Employee()
  {
  }
  public Employee(String no)
  {
    this.setEmpno(no);
    this.setName("无名氏");
    this.setSalary(0.0f);
    this.setDept("未定");
  }
  public Employee(String no,String na)
  {
    this.setEmpno(no);
    this.setName(na);
    this.setSalary(1000.0f);
    this.setDept("后勤");
  }
  public Employee(String no,String na,float sa,String d)
  {
    this.setEmpno(no);
    this.setName(na);
    this.setSalary(sa);
    this.setDept(d);
  }
  //显示信息
        public void showMsg()
  {
    System.out.println("员工信息为：");
    System.out.println("\t|- 员工号："+empno);
    System.out.println("\t|- 姓名："+name); 
    System.out.println("\t|- 薪水："+salary);
    System.out.println("\t|- 部门："+dept);
  }
  //代码之后必须有setter和getter
  public void setEmpno(String a)
  {
    empno=a;
  }
  public void setName(String n)
  {
    name=n;
  }
  public void setSalary(float s)
  {
    if (s>=0.0f)
    {
      salary=s;
    }
  }
  public void setDept(String d)
  {
    dept=d;
  }
  public String getEmpno()
  {
    return empno;
  }
  public String getName()
  {
    return name;
  }
  public float getSalary()
  {
    return salary;
  }
  public String getDept()
  {
    return dept;
  }
}
//主类
public class ooDemo10
{
  public static void main(String args[])
  {
    Employee e1=new Employee("e001","王乾");
    Employee e2=new Employee("e002","王乾",10000.0f,"开发部");
    e1.showMsg();
    e2.showMsg();
  }
}

我们发现分别调用成功了，这就是构造方法的使用哈~

 

总结：

1、封装性
· 对外不不可见，属性前加入private关键字
· 通过setter和getter方法设置和取得封装属性
2、构造方法
· 与类名称相同，无返回值类型
· 在对象实例化（new）的时候被自动调用
· 构造方法可以重载
· 每个类中至少有一个构造方法
3、匿名对象：只使用一次的对象。