5. 面对对象(基础) Part 3 --- 学习笔记

5.14内部类
       在类内部可定义成员变量与方法，而且在类内部也可以定义另一个类。如果在类Outer的内部再定义一个类Inner，此时类Inner就称为内部类，而类Outer则称为外部类。
       内部类可声明称public或private。当内部类声明称public或private时，对其访问的限制与成员变量和成员方法完全相同。

1. 内部类的声明格式:
标识符 class 外部类的名称{

       //外部类的成员

     标识符 class内部类的名称{

             //内部类的成员

      }

}

范例 1:

class Outer {

      private String info = “Hello World!!!”;

      class Inner{

             public void print(){

                    System.out.println(info);

             }

      }

      public void fun(){

             new Inner().print();         

      }

}

public classInnerClassDemo01{

      public static void main(String args[]){

             new Outer().fun();              

      }

}
但是，内部类的存在实际上已经破坏了一个类的基本结构。因为类是由属性及方法组成的，所以这也是内部类的一个缺点。
内部类的优点在于: 把内部类拿到外面来定义。 代码如下:
class Outer{
     private String info = "hello world!!!";
     public String getInfo(){
          return this.info;
     }
     public void fun(){
          new Inner(this).print();
     }
}

class Inner{
     private Outer out = null;
     public Inner(Outer out){
          this.out = out;
     }
     public void print(){
          System.out.println(out.getInfo());
     }
}

public class InnerClassDemo02{
     public static void main(String args[]){
          new Outer().fun();
     }
}
内部类唯一的好处就是可以方便地访问外部类中的私有属性。

2.  使用static定义内部类
     用static声明的内部类变成了外部类，但是用static声明的内部类不能访问非static的外部类属性。

3.  在外部访问内部类
     一个内部类除了可以通过外部类访问，也可以直接在其他类中进行调用。
     调用的基本格式为
     外部类.内部类    内部类对象 =  外部类实例.new  内部类();
     *******首先要实例化外部类的对象，然后才可以通过外部类的实例化对象去实例化内部类的对象*******
     *****内部类定义之后，生成的class文件是以Outer$Inner.class的形式存在的。在java中只要在文件中存在$，那么在程序中都应替代为“.”。*****
class Outer{
     private String info = "Hello World!!!";
     class Inner{
          public void print(){
               System.out.println(info);
          }
     }
}

public class InnerClassDemo02{
     public static void main(String args[]){
          Outer out = new Outer();
          //Outer.Inner in = new out.Inner();    Wrong!!!!!!!!!!!!
          Outer.Inner in = out.new Inner();
          in.print();
     }
}

4. 在方法中定义内部类
      可以在方法中定义一个内部类，但是在方法中定义的内部类不能直接访问方法中的参数。
      如果方法中的参数要想被内部类访问，则参数前必须加上final关键字。
   实例:
class Outer{
     private String info = "Hello World!!!";
     public void fun(final int temp){
          class Inner{
               public void print(){
                    System.out.println("the attribute in class: " + info);
                    System.out.println("the argument in method: " + temp);
               }
          }
          new Inner().print();
     }
}

public class InnerClassDemo03{
     public static void main(String args[]){
          new Outer().fun(30);
     }
}

5.14  实例讲解

1. 系统登陆实例
     Problem: 模拟一个简单的用户登录程序，此处使用初始化参数的方式输入用户名和密码。
     Analyse:  既然使用了初始化参数的方法输入用户名和密码，那么在程序运行之前首先必须判断输入的参数是否合法，如果不合法，则必须提示用户的程序执行错误，并直接退出程序
     如果用户正确地输入了参数，则可以进行用户名及密码的验证，如果信息正确则正确显示“欢迎XXX光临”，否则显示“错误的用户名或者密码”。
实现一:   基本功能实现
class LoginTest(){
     public static void main(String args[]){
          if (args.length != 2){
               System.out.println("form Wrong, please type like this: Java LoginTest user_name user_password");
               System.exit(1);
          }
          String name = args[0];
          String password = args[1];

          if (name.equals("csdn") && password.equals("123qwe456")){
               System.out.println("Welcome back, " + name);
          }else{
               System.out.println("Wrong user name or password, please try again!");
          }
     }
}

实现二:   分离各种信息判断
class Check{
     public boolean validate(String name, String password){
          if (name.equals("csdn") && password.equals("123qwe456")) {
                    return true;
          }else {
                    return false;
     }
}
class Operate{
     private String info[];
     public Operate(String info[]){
          this.info = info;
     }
     
     public String login(){
          this.ifLegal();
          String str = null;
          Check check = new Check();
          String name = this.info[0];
          String password = this.info[1];

          if (check.validate(name, password) {
               str = "Welcome back," + name;
          }else {
               str = "the name or password was wrong, please try again!";
          }
          
          return str;
}

     public void ifLegal(){
          if (this.info.length != 2){
               System.out.println("The form that you type was incorrect, please type like this: Java LoginTest user_name user_password");
               System.exit(1);
     }
}

public class LoginTest(){
     public static void main(String args[]){
          Operate ope = new Operate(args);
          System.out.println(ope.login());
     }
}

上面第二种实现方式的优点在于:
     1. 主方法处代码较少，因为是客户端，所以应该要方便客户使用。(胖服务器/瘦客户机)
     2. Check类的主要功能就是验证操作，只需要传入用户名和密码即可完成验证。
     3. Operate类的主要功能就是封装Check类的操作，并把Check的信息返回给调用处。

以上程序的调用关系如下图所示