java复习 面向对象4

构造方法私有化:
  类的封装性不光体现在对属性的封装上,实际上方法也是可以被封装的
  一个类的构造方法被私有化之后,则只能在类的内部取得实例化对象,所以
  在类的内部先声明成static类型,若封装起来,则加getInstance()方法返回
  类的实例.
  单台设计模式:
  1.将构造方法私有化
  2.在类的内部定义static类型的类类型的变量
  3.在类的内部定义返回类实例的方法(加入判断)
  用此模式只产生一个对象(一个内存地址)
  public class Singleton
  {
     private Singleton()
     {
    
     }
     private static Singleton st = null;
    
     public Singleton getInstance()
     {
        if(st==null)
 {
   st = new Singleton();
 }
 return st;
     }
  }

对象数组:
  所谓对象数组就是一组相关的对象
  对象数组的声明:     类 对象数组名称[] = new 类[数组长度];
  数组本身事属于引用数据类型的:而类本身也是属于引用数据类型的,所以不管是
  引用还是基本数据类型都可以使用数组的格式进行声明并使用.
  对象数组也分为静态和动态的.在没有实例化之前,值都为空.
  eg:
  public class Person
  {
      private String name;
      public Person(String name)
      {
          this.name = name;
      }
      public String getName()
      {
         return this.name;
      }
  }
  动态初始化:
  Person per[] = new Person[2]; //在没有实例化之前为null;
  per[0] = new Person("张三");  //为数组元素实例化
  per[1] = new Person("李四");
  静态初始化:
  Person per[] = {new Person("张三"),new Person("李四")};
  对象数组元素获取属性:per[1].getName();

内部类:
  在一个类的内部还存在一个类,则称为内部类,内部类可以声明为public或
  private,当内部类声明成public或private时,对其访问的限制与成员变量和
  成员方法完全相同.
  优点:可以访问外部类的私有属性.
  使用static声明内部类,则此内部类就称为外部类,可以直接通过外部类.内部类
  进行访问.但是如果要想访问外部类的属性,则属性必须是static.

  在外部类访问内部类格式:
  外部类.内部类 内部类对象 = 外部类实例.new 内部类();

  内部类在任意的位置上定义
 
系统登录:
   验证用户密码类:
   class Check
   {
       public boolean isLogin(String name,String pass)
       {
          if("cyq".equals(name)&&"1234".equals(pass))
   {
      //System.out.println("登陆成功!");
      return true;
   }
   else
   {
       //System.out.println("登陆失败!");
       return false;
   }
       }
   }
  验证参数类:
  class Exit
  {
     public boolean len(String exit[])
     {
        if(args.length!=2)
 {
    System.out.println("参数不正确!请重新登陆!");
    System.out.println("/n参数格式为:java LoginMain 参数1 参数2");
    System.exit(1);
 }
     }
  }
 登陆类:
 class Login()
 {
    private String[] info;
    public Login(String info[])
    {
        this.info = info;
    }

    String name = info[0];   //传递参数
    String pass = info[1];
    String str = null;

    Exit exit = new Exit();
    Check check = new Check();
  
   public String message()
   {
      if(exit.len())    //验证长度
 {
     if(check.isLogin(name,pass)) //验证参数
       {
   str = "登陆成功!"+"欢迎"+name+"光临";
       }
     else
       {
  str = "登陆失败!请重新登陆!";
       }
  }
    }

    return str;
 }
 程序入口:
  public class LoginMain
  {
     public static void main(String args[])
     {
        Login l = new Login(args);
 System.out.println(l.message());
     }
  }

单向链表
  链表是在数据结构中将常见到的一种形式,实际上在java中也可以通过引用传递
  的方式进行实现,必须设计节点类,一个节点类除了要保存自己的内容之外,还要保存
  下一个节点的引用.
 eg:
  class Node
  {
     private String data; //保存节点的内容
     private Node next;   //保存下一个节点

     public Node(String data)
     {
         this.data = data;
     }

     public void setData(String data)//设置节点的内容
     {
        this.data = data;
     }
     public String getData()
     {
         return this.data;
     }

     public void setNext(Node next)
     {
        this.next = next;
     }

     public Node getNext()
     {
        return this.next;
     }
  }
 public class NodeDemo
 {
    public static void main(String args[])
    {
       Node root = new Node("火车头");     //实例化根节点
       Node n1 = new Node("车厢A");      //实例化第一个节点
       Node n2 = new Node("车厢B");      //实例化第2个节点
       Node n3 = new Node("车厢C");      //实例化第3个节点
       Node n4 = new Node("车厢D");      //实例化第4个节点
       root.setNext(n1);                 //保存下一个节点的引用
       n1.setNext(n2);                //第一个节点设置下一个节点为第二个
       n2.setNext(n3);                //第二个节点设置下一个点解为第三个节点
       n3.setNext(n4);

       printNode(root);   //从头开始输出
    }

    public void printNode(Node node)
    {
         System.out.print(node.getData());
  if(node.getNext()!=null)
  {
     printNode(node.getNext());   //递归调用
  }
    }
 }