黑马程序员_面向对象（一）

android培训、java培训

面向对象三大特征：1、封装（对外不可见）2、继承（扩展类的功能） 3、多态（方法的重载、对象的多态）

类是对象的模板，对象是类的具体实现。

类的定义格式：

class 类名称

{

       属性；//属性也叫变量

       方法；//方法也叫成员方法

}

对象的定义格式：类名 对象名 = new 类名（）

class Person {        String name;        int age; } public class JavaDemo45 {        public static void main(String args[])        {               //声明对象格式：类对象名 = new类（）；               //Person lxh1;   声明一个对象lxh1               //lxh1 = new Person();  为对象实例化开辟堆内存空间把使用权给lxh1               Person lxh1 = new Person();               //为Person类中的属性赋值               lxh1.name = "李岩";//格式：对象.属性为对象中的属性赋值               lxh1.age = 23;               System.out.println("lxh1姓名："+lxh1.name);               System.out.println("lxh1年龄："+lxh1.age);               System.out.println("===================");               Person lxh2 = new Person();               lxh2 = lxh1;//对象的引用传递               lxh2.name = "SkyOnLine";               lxh2.age = 20;               //对象产生之后会自动为其赋值数字类型=0其它类型=null               System.out.println("lxh1姓名："+lxh1.name);               System.out.println("lxh1年龄："+lxh1.age);               System.out.println("lxh2姓名："+lxh2.name);               System.out.println("lxh2年龄："+lxh2.age);        } }

如果不使用new开辟对内存空间，可以编译，但运行时候出现“NullPointerException（空间指向异常）”的错误。

程序中不在有任何指向的堆内存被称为垃圾，会被JVM中垃圾收集（GC）自动回收。

class Person {        String name;        int age; } public class JavaDemo46 {        public static void main(String args[])        {               Person lxh1 = new Person();               lxh1.name = "李岩";               lxh1.age = 23;               System.out.println("lxh1姓名："+lxh1.name);               System.out.println("lxh1年龄："+lxh1.age);               System.out.println("===================");               Person lxh2 = new Person();               lxh2 = lxh1; //lxh2的name、age赋值就变成了垃圾垃圾将被JVM自动收集垃圾收集（CG）               lxh2.name = "SkyOnLine";               lxh2.age = 20;               System.out.println("lxh1姓名："+lxh1.name);               System.out.println("lxh1年龄："+lxh1.age);               System.out.println("lxh2姓名："+lxh2.name);               System.out.println("lxh2年龄："+lxh2.age);        } }

栈：对象名       堆：对象属性    全局代码：所有方法

在类中加入输出方法：

class Person {        String name;        int age;        public void shout()//增加一个让Person说话的方法        {               System.out.println("姓名："+name);               System.out.println("年龄："+age);        } } public class JavaDemo47 {        public static void main(String args[])        {               Person lxh1 = new Person();               lxh1.name = "李岩";               lxh1.age = 23;               Person lxh2 = new Person();               lxh2.name = "SkyOnLine";               lxh2.age = 20;               lxh1.shout();               System.out.println("===================");               lxh2.shout();        } }

一个类中可以定义多个方法，在类的内部这些方法可以互相调用，用this表示当前类之中的方法。

class Person {        String name;        int age;        public String shout()//增加一个让Person说话的方法        {               this.run();//this关键字表明从本类中调用               return "姓名："+this.name+"\n年龄："+this.age;        }        public void run()        {               System.out.println("跑步！！！！");        } } public class JavaDemo48 {        public static void main(String args[])        {               Person lxh1 = new Person();               lxh1.name = "李岩";               lxh1.age = 23;               Person lxh2 = new Person();               lxh2.name = "SkyOnLine";               lxh2.age = 20;               System.out.println(lxh1.shout());               System.out.println("===================");               System.out.println(lxh2.shout());        } }

当age=-30；错误出现了，原因是age、name两个属性对外部而言是直接访问的。

前提：属性不能让外部看见（private关键字）；之后：需要在此处加入检测措施。

用priveta关键字实现类的封装。用setter、getter方法对私有变量进行操作。

class Person {        //priveta声明的属性只能在本类中看到        private String name;        private int age;        //加入一些列的setter和getter方法        public void setName(String n)        {               name = n;        }        public void setAge(int a)        {               if (a<=0&&a>=100)//检测措施判断age值是否合法               {                      age = a;               }               else               {                      age = -1;               }        }        public String getName()        {               return name;        }        public int getAge()        {               return age;        }        public String shout()        {               return "姓名："+this.name+"\n年龄："+this.age;        } } public class JavaDemo50 {        public static void main(String args[])        {               Person lxh1 = new Person();               lxh1.setName ("李岩");//set是方法用（）               lxh1.setAge(-30);               System.out.println(lxh1.shout());        } }

构造方法的特点：1、它具有与类相同的名称2、它不含返回值类型的定义 3、不能在方法中使用return语句返回一个值

构造方法调用时机：在实例化对象时被自动调用，主要为类中的属性（变量）初始化。

class Person {        private String name;        private int age;        //加入一个构造方法        Person(int a,String n)//创建实例使用new关键字时将被调用        {               System.out.println("构造方法被调用！！！");               //为类中的属性初始化               name = n;                      if (a<=0&&a>=100)               {                      age = a;               }               else               {                      age = -1;               }        }        public String shout()        {               return "姓名："+this.name+"\n年龄："+this.age;        } } public class JavaDemo51 {        public static void main(String args[])        {               Person lxh1 = new Person(-30,"李岩");//new调用构造方法               System.out.println(lxh1.shout());        } }

在Java中每个类必须有一个构造方法，如果没有构造方法，则会自动生成一个无惨的什么都不做的构造方法，因此所有对象产生时都必须调用构造方法。

如果已经明确写出了构造方法，则不会在产生无惨的构造方法。

class Person {        private String name;        private int age;        //加入一个构造方法        Person(int age,String name)//创建实例只用new关键字时将被调用        {               System.out.println("构造方法被调用！！！");               //为类中的属性初始化        //name = "noname";        //age = 30;               this.setName(n);               this.setAge(a);        }        public void setName(String n)        {               name = n;        }        public void setAge(int a)        {               if (a<=0&&a>=100)               {                      age = a;               }               else               {                      age = -1;               }        }        public String getName()        {               return name;        }        public int getAge()        {               return age;        }        public String shout()        {               return "姓名："+this.name+"\n年龄："+this.age;        } } public class JavaDemo52 {        public static void main(String args[])        {               Person lxh1 = new Person(-30,"李岩");               System.out.println(lxh1.shout());        } }

无论采用哪种方法为类中的属性赋值，最好都经过setter方法，由setter方法对输入的内容进行检测，getter方法只是将内容简单的返回。

 

匿名对象：不定义对象的引用名称，直接调用这个对象的方法。

class Person {        private String name;        private int age;        Person(String n,int a)//创建实例只用new关键字时将被调用        {               System.out.println("构造方法被调用！！！");               this.setName(n);  //为类中的属性初始化               this.setAge(a);        }        public void setName(String n)        {               name = n;        }        public void setAge(int a)        {               if (a>=0&&a<=100)               {                      this.age = a;               }               else               {                      this.age = -1;               }        }        public String getName()        {               return this.name;        }        public int getAge()        {               return this.age;        }        public String shout()        {               return "姓名："+this.name+"\n年龄："+this.age;        } } public class JavaDemo53 {        public static void main(String args[])        {               System.out.println(new Person("Rockma",23).shout());               //匿名对象不创建对象名直接调用类中方法               //匿名对象只能被使用一次 经常作为实参传递给一个函数调用        } }

newPerson("Rockma",23).shout()：对象是存在的，并且已经开辟了堆空间，只是没有对象名指向它（栈空间没有开辟）。（经常作为方法的参数出现使用）

public class JavaDemo54 {        public static void main(String args[])        {               //String 类中有一个构造方法：String ("String")               String name1 = "李岩";               String name2 = new String ("李岩");               String name3 = name1;               System.out.println("name1 = "+name1);               System.out.println("name2 = "+name2);               System.out.println("name3 = name1");               System.out.println("name1 == name2："+(name1 == name2));               //String类的一个方法：public boolean equals(String str)               System.out.println("name1 equals name2："+name1.equals(name2));               System.out.println("name1 == name3："+(name1 == name3));               System.out.println("李岩".equals(name2));//"李岩"可以直接调用String类中的方法，一个字符串就是String类的匿名对象        } }

String name1 ="李岩"; 只开辟了一个空间 字符串就是String类的匿名对象

String name2 = newString ("李岩"); 开辟了"李岩"、new两个空间 在把"李岩"指向new开辟的空间 其中一个就变成了垃圾空间

public class JavaDemo55 {        public static void main(String args[])        {//String的特殊之处当两个字符串的值一样时使用相同的地址空间               String name1 = "李岩";               String name2 = "李岩";               System.out.println(name1 == name2);        //name1、name2使用相同的地址空间 String使用Java中的共享设计模式        } }

equals：比较的时字符串的内容 ==：值比较，比较的而是内存地址

只要出现字符串，就会开辟堆内存空间，与数值类型不同。

String类中的内容一但声明就不可改变。除非开辟新的空间

public class JavaDemo57 {        public static void main(String args[])        {               String str1 = "李岩";//声明后无法改变               fun(str1);               System.out.println(str1);        }        public static void fun(String str2)        {               str2 = "Rockman";        } }

class Person {        int x = 0; } public class JavaDemo56 {        public static void main(String args[])        {               Person p1 = new Person();               p1.x = 30;               fun(p1);               System.out.println(p1.x);        }        public static void fun(Person p2)        {               p2.x = 50;        } }

class Person {        String name ; }; public class JavaDemo58 {        public static void main(String args[])        {               Person p1 = new Person() ;               p1.name = "魔乐" ;//操作对象为Person类传递的也是Person类值改变               fun(p1) ;               System.out.println(p1.name) ;        }        public static void fun(Person p2)        {               p2.name = "李兴华" ;        } };

String中要回避的程序写法：

// 回避一种写法 // 如果程序中非要使用此种类型的代码，则可以使用StringBuffer代替 // StringBuffer与String的本质区别，在于StringBuffer可以改变 public class JavaDemo59{        public static void main(String args[])        {               String str = "A" ;               for(int i=0;i<100;i++)               {                      str += i ;               }               System.out.println(str) ;        } };
public class StringAPI01{        public static void main(String[] args){               String str = "Hello";               char c = str.charAt(1);//取出str中下标为1的字符               System.out.println(c);        } }
public class StringAPI02{        public static void main(String[] args){               String str = "Hello World";               char[] c = str.toCharArray();//将字符串变阵字符数组               for (int i=0 ;i<c.length ;i++ )               {                      System.out.println(c[i]);               }               String str1 = new String(c);//将字符数组变成字符串               String str2 = new String(c,0,4);//将字符数组变成字符串,取出数组中下标0-4的值               System.out.println(str1);               System.out.println(str2);        } }
public class StringAPI03{        public static void main(String[] args){               String str = "hello";               byte[] b = str.getBytes();//将字符串变为byte数组               for (int i=0 ;i<b.length ;i++ )               {                      System.out.println(b[i]);               }        } }
public class StringAPI04{        public static void main(String[] args){               String str = "Hello World";               byte[] b = str.getBytes();//将字符串变阵byte数组               String str1 = new String(b);//将byte数组变成字符串               String str2 = new String(b,0,5);//将byte数组变成字符串,取出数组中下标0-4的值               System.out.println(str1);               System.out.println(str2);        } }
public class StringAPI05{        public static void main(String[] args){               String str = "hello";               System.out.println(str.startsWith("h"));//判断字符串是否以h开始               System.out.println(str.endsWith("o"));//判断字符串是否以o结束        } }
public class StringAPI06{        public static void main(String[] args){               String str = "hello Lee";               String newStr = str.replaceAll("l","X");//把字符串中的“ll”替换为“XX”               System.out.println(newStr);        } }
public class StringAPI07{        public static void main(String[] args){               String str = "hello Lee";               String sub1 = str.substring(5);//全部截取操作，从下标5开始到结束               String sub2 = str.substring(0,5);//部分截取操作，从下标0-5               System.out.println(sub1);               System.out.println(sub2);        } }
public class StringAPI08{        public static void main(String[] args){               String str = "hello Lee";               String[] s = str.split(" ");//对字符串进行拆分，按“空格”拆分               for (String i: s )               {                      System.out.println(i);               }        } }
public class StringAPI09{        public static void main(String[] args){               String str = "hello Lee";               System.out.println(str.contains("hello"));//查找操作，直接查找，str中是否包含hello               System.out.println(str.contains("MLDN"));//查找操作，str中是否包含MLDN               System.out.println(str.indexOf("hello"));//查找到了返回0               System.out.println(str.indexOf("MLDN"));//没有查找到返回-1               if (str.indexOf("hello")!=-1)//日常使用               {                      System.out.println("find");               }else{                      System.out.println("don't find");               }        } }
public class StringAPI11{        public static void main(String[] args){               String str = " hello Lee ";               String newStr = str.trim();//去掉空格，但只能去掉左右的不能去掉中间的               System.out.println(newStr);               int i = str.length();//取得字符串的长度               System.out.println(i);        } }
public class StringAPI10{        public static void main(String[] args){               String str = "hello Lee";               System.out.println(str.indexOf("hello"));//查找到了返回0               System.out.println(str.indexOf("h",2));//没有查找到返回-1,查找h但是从指定的下标2开始查找        } }
public class StringAPI12{        public static void main(String[] args){               String str1 = " hello lee ";               String strU = str1.toUpperCase();//转大写               String str2 = "HELLO LEE";               String strL = str2.toLowerCase();//转小写               System.out.println(strU);               System.out.println(strL);        } }
public class StringAPI13{        public static void main(String[] args){               String str = "TOM:11|JERRY:22|TONY:33";//对内容进行拆分               String[] s = str.split("\\|");               for (int i=0;i<s.length ;i++ )               {                      String[] st = s[i].split(":");                      System.out.println(st[0]+"-->"+st[1]);               }        } }
public class StringAPI14{        public static void main(String[] args){               System.out.println(valdate("mvpleelive.com"));        }        public static boolean valdate(String email){               boolean flag = true;               if (email.indexOf("@")==-1 || email.indexOf(".")==-1)               {                      flag = false;               }               if (flag)               {                      if (!(email.indexOf("@")<email.indexOf(".")))//0<-1email正确，取反                      {                             flag = false;                      }               }               return flag;        } }

this调用属性：

class Person{//this调用本类中的属性        private String name;        public void setName(String name)        {               //name = name;//两个name都是setName()方法中的参数name               this.name = name;//this表示当前类中的属性               //this.name表示Person类中声明的name区别于setName()方法中的参数        }        public String getName()        {               return this.name;        } } public class JavaDemo60{        public static void main(String args[])        {               Person pname = new Person();               pname.setName("李岩");               System.out.println(pname.getName());        } }

this调用本类中的方法：

class Person {//this调用本类中的方法        private String name;        public void setName(String name)        {               this.print();//不加this程序也能运行，加this表示强调时本类中的方法               this.name = name;        }        public String getName()        {               return this.name;        }        public void print()        {               System.out.println("setName方法中的name参数被赋值了！");        } } public class JavaDemo61 {        public static void main(String args[])        {               Person pn = new Person();               pn.setName("Rockman");               System.out.println(pn.getName());        } }

this调用本类中的构造方法：

//this调用本类中的构造方法 class Person {        private String name;        private int age; /*1\程序要提供一个无参的构造方法，此构造方法用于打印创建person对象的信息 2\程序要再提供一个设置姓名的方法，年龄的默认值为1，但此方法也要打印对象创建信息 3\程序要再再提供一个有两个参数的构造方法，用于设置姓名和年龄，但要求也打印对象创建信息*/        Person()        {               System.out.println("构造方法被调用！！！");        }        Person(String name)//构造方法被重载        {               System.out.println("构造方法被调用！！！");               this.setName(name);               this.setAge(1);        }        Person(String name,int age)        {               System.out.println("构造方法被调用！！！");               this.setName(name);               this.setAge(age);        }        //发现有一些代码重复使用了，用this完成构造方法间的相互调用        public void setName(String name)        {               this.name = name;        }        public void setAge(int age)        {               this.age = age;        }        public String getName()        {               return this.name;        }        public int getAge()        {               return this.age;        } } public class JavaDemo62 {        public static void main(String args[])        {        } }

使用this完成构造方法的调用：

//this调用本类中的构造方法 class Person {        private String name;        private int age;        Person()        {               System.out.println("构造方法被调用！！！");        }        Person(String name)        {               this();//调用本类中无惨的构造方法               this.setName(name);               this.setAge(1);        }        Person(String name,int age)//this调用构造方法会在类中一层一层的向上传递        {//用this调用构造方法时必须放在本构造方法的首行               this(name);//把String name传给本类中Person(String name)构造方法               this.setAge(age);        }            public void setName(String name)        {               this.name = name;        }        public void setAge(int age)        {               this.age = age;        }        public String getName()        {               return this.name;        }        public int getAge()        {               return this.age;        } } public class JavaDemo63 {        public static void main(String args[])        {               Person p1 = new Person();               Person p2 = new Person("李岩");               Person p3 = new Person("李岩",23);        } }

this调用的构造方法必须在首行被调用，为了能为类中的属性初始化。

this用法：1、调用属性        2、调用方法     3调用构造方法

以上3点可以综合成1点——表示当前对象。

class Person {        String name;        int age;        Person (String name,int age)        {               this.name = name;               this.age = age;        }        public void print()        {               System.out.println("print方法中的："+this);               //this表示当前调用自己的对象 p1调用就表示p1 p2调用就表示p2        } } public class JavaDemo64 {        public static void main(String args[])        {               Person p1 = new Person("张三",23);               System.out.println("main中的方法"+p1);               p1.print();//this当前对象为p1               System.out.println("+++++++++++++++++++++++");               Person p2 =new Person("李四",32);               System.out.println("main中的方法"+p2);               p2.print();//this当前对象为p2        } }

this表示当前对象时主要应用在对象的比较。

class Person {        private String name;        private int age;        public void change(Person p)        {//name、age都是被封装了外部不能访问但是可以把对象p当做参数一样传会类中    //打破了封装的概念很特殊               p.name = "李四";               p.age = 40;        }        public void print()        {               System.out.println("名字："+this.name);               System.out.println("年龄"+this.age);        } } public class JavaDemo65 {        public static void main(String args[])        {               Person p = new Person();               p.change(p);               p.print();        } }

class Person {        private String name ;        private int age ;        public Person(String name,int age)        {               this.name = name ;               this.age = age ;        }        public boolean compare(Person p1) //拿来跟我比的人        {               boolean flag = false ;               Person p2 = this ; //发起比较的人               if(p1.name.equals(p2.name)&&p1.age==p2.age)               {                      flag = true ;               }               return flag ;        }        public void print()        {               System.out.println("姓名："+this.name) ;               System.out.println("年龄："+this.age) ;        } }; public class JavaDemo66 {        public static void main(String args[])        {               // 假设认为，名字和年龄相等的就是同一个人               Person per1 = new Person("张三",30) ;               Person per2 = new Person("张三",31) ;               System.out.println(per1.compare(per2)?"是同一个人":"不是同一个人") ;        } };

对象数组的创建：数组缺点：个数固定

class Person {        private String name;        private int age;        Person(String name,int age)        {               this.name = name;               this.age = age;        }        public void print()        {               System.out.println("姓名："+this.name);               System.out.println("年龄："+this.age);        } } public class JavaDemo67 {        public static void main(String args[])        {               // 对象数组：类名称对象数组名[] = null ;对象数组名 = new类名称[]               Person p[] = new Person [10];               // 对象数组在使用时需要为每一个元素[对象]分别实例化               p[0] = new Person("李0",31) ;               p[1] = new Person("李1",32) ;               p[2] = new Person("李2",33) ;               p[3] = new Person("李3",34) ;               p[4] = new Person("李4",35) ;               p[5] = new Person("李5",36) ;               p[6] = new Person("李6",37) ;               p[7] = new Person("李7",38) ;               p[8] = new Person("李8",39) ;               p[9] = new Person("李9",40) ;               for (int x=0;x<p.length ;x++ )               {                      p[x].print();                      System.out.println();               }        } };

四个内存区域：1、栈内存：保存对象的名称。

                            2、对内存：对象的具体内容（属性）。

                            3、全局代码：所有方法。

                            4全局数据：存放static类型的属性

在类中用static声明一个属性，表示此属性为公有的。即：所有对象都能访问。

对于static类型的属性，最好通过类名称修改，static声明的属性和方法可以通过类名称直接调用。

//为了将讲解static属性暂不加封装 class Person {        private static String code;//code为共享区域//对code进行封转        String name;        int age;        String shout()//非静态方法可以调用静态、非静态方法和属性        {               return "地区编码："+code+"，姓名："+name+"，年龄："+age;        }        static void setCode(String c)        {//静态方法可以由类直接调用               code = c;//this表示一个对象，static中不能使用this关键字        }        /*static void setName(String n);        {//静态方法不能调用非静态的方法和属性               name = n;        }*/ } class JavaDemo68 {        public static void main(String args[])        {               Person.setCode("111");               //Person.code = "111";//static声明的属性或方法可以直接被类调用               Person p1 = new Person();               Person p2 = new Person();               p1.name = "李岩";               //p1.code = "110";               p1.age = 23;               p2.name = "来了";               //p2.code = "120";//由于code是共享区域p1.code将被改变               p2.age = 22;               System.out.println(p1.shout());               System.out.println(p2.shout());        } }

静态方法：不能调用非静态方法或属性

非静态方法：能调用静态、非静态方法或属性

四种代码块：

       1、普通代码块：写在方法之中的代码

public class JavaDemo69 {        public static void main(String args[])        {               {//普通代码块写在方法之中                      int i = 0;//作用范围在大括号内               }               int i = 10;               System.out.println(i);        } }

2、构造代码块：直接写在类中的语句块，构造块优先于构造方法，执行多次。

       3、静态块：直接写在类中的，通过static声明的语句块，优先于构造块、构造方法，作用为静态属性初始化，只执行一次

class Person {        static        {// 静态代码块：写在类中static语句块中               System.out.println("静态代码块执行！！！") ;        }        {//构造代码块：写在类中               System.out.println("构造代码块执行！！！");        }        Person()        {//构造方法代码块：写在构造方法中               System.out.println("构造方法代码块执行！！！");        } } public class JavaDemo70 {        public static void main(String args[])        {               new Person();               new Person();//静态块只执行一次        } }

       4、同步代码块：多线程应用

public：表示此方法为公共的，可被外部访问的。

static：表示此方法为静态的，可被类名称直接调用。

void：无返回值。

main：系统规定的方法名称。

String args[]：接受运行时参数。

类在运行时要调用main方法，main要被外部所看见，所以main方法声明为public，程序运行时输入的都是类名称，证明使用类名称调用方法，所以声明main方法为static，Stringargs[]表示接受的参数，格式：java 类名称 参数1 参数2 ...

public class JavaDemo71 {// 测试运行时的参数        public static void main(String args[])        {               for (int i=0;i<args.length;i++)               {                      System.out.println(args[i]) ;               }        } };

通过包装类可以将String类型转换为int类型。

Java中有一种思想：一切接对象一切的操作都有对象

类型	包装类
int	Integer
char	Character
float	Float
double	Double
byte	Byte
short	Short
long	Long
boolean	Boolean

将String转变为int：Integer.parseIn(String 变量名);

public class JavaDemo72 {        public static void main(String args[])        {               String num = "22";               int temp = Integer.parseInt(num); //此方法必须保证字符串都是由数字组成的               System.out.println(temp * 2);        } }

System.exit(1);退出程序，不在向下执行。

/*由运行参数输入Person类中的名字和年龄，并输出打印*/ class Person {        String name;        int age;        public String talk()        {               return "姓名："+"\t年龄："+age;        } } public class JavaDemo73 {        public static void main(String args[])        {               //如果程序没有发现参数，则表示出错，并且推出程序               if (args.length != 2)//参数不足两个退出程序               {                      System.out.println("程序出错并退出！！！");                      System.exit(1);//表示程序退出不在向下执行               }               //第一个参数为name，第二个参数为age               String name1 = args[0];//数组0元素保存name               int age1 = Integer.parseInt(args[1]);//数组1元素保存年龄               Person p = new Person();               p.name = name1;//赋值给对象               p.age = age1;//赋值               System.out.println(p.talk());        } }

class Login {        private String[] args;        public Login(String[] args){               this.args = args;        }        public boolean valiDate(){               String userName = this.args[0];               String passWord = this.args[1];               if (userName.equals("admin")&&passWord.equals("pass"))               {                      return true;               }else{                      return false;               }        } } public class TestLogin {        public static void main(String[] args){               if (args.length !=2)               {                      System.out.println("参数有误，格式为：java TestLogin username password");                      System.exit(1);               }               System.out.println(new Login(args).valiDate()?"登陆成功":"登陆失败");        } }

class Login {        private String userName;        private String passWord;        public Login(String userName,String passWord){               this.userName = userName;               this.passWord = passWord;        }        public boolean valiDate(){                     if (userName.equals("admin")&&passWord.equals("pass"))               {                      return true;               }else{                      return false;               }        } } class Operate {        private String[] args;        public Operate(String[] args){               this.args = args;               if (args.length !=2)               {                      System.out.println("参数有误，格式为：java TestLogin username password");                      System.exit(1);               }        }        public String getInfo(){               if (new Login(args[0],args[1]).valiDate())               {                      return "登陆成功";               }else{                      return "登陆失败";               }        } } public class TestLogin {        public static void main(String[] args){               System.out.println(new Operate(args).getInfo());                      } }

class Node {        private String name;        private Node next;          public Node(String name){               this.name = name;        }          public void setNext(Node next){               this.next = next;        }        public Node getNext(){               return this.next;        }        public String getName(){               return this.name;        } } public class TestLink {        public static void main(String[] args){               Node root = new Node("Root");               Node one = new Node("One");               Node two = new Node("Two");               Node three = new Node("Three");                      root.setNext(one);               one.setNext(two);               two.setNext(three);                 print(root);        }        public static void print(Node node){               if (node!=null)               {                      System.out.print(node.getName()+"--->");               }               if (node.getNext()!=null)               {                      print(node.getNext());               }        } }