1、 类的基本形式例 1：类与对象public class TestPersonDemo public static void main(String args)Person p=new Person();/声明 Person 对象 p 并直接实例化此对象p.name=“张三“;/访问 Person 类中的 name 属性并赋值p.age=25;/访问 Person 类中的 age 属性并赋值p.talk();/调用 Person 类中的 talk()方法class PersonString name;int age;void talk()System.out.println(“我是：“+name
2、+“,今年：“+age+“岁“);注：1、 对象的静态特征抽象为属性，用数据来描述，在 java 语言中称之为变量；对象的动态特征抽象为行为，用一组代码来表示，完成对数据的操作，在 java 语言中称之为方法。一个对象由一组属性和一组对属性进行操作的方法构成。2、 类是具有相同属性及相同行为的一组对象。它有一个类名，其内部包括成员变量和成员方法。类是一个抽象概念，要利用类的方式来解决问题，必须用类创建一个实例化的类对象，然后通过类对象去访问类的成员变量，去调用类的成员方法来实现程序的功能。3、 面向对象的程序设计有三个主要特征：封装性、继承性、多态性。例 2：创建多个对象class Perso
3、nString name;int age;void talk() System.out.println(“我是：“+name+“, 今年：“+age+“岁“);public class TestPersonDemo1 public static void main(String args)Person p1=new Person();/声明并实例化一 Person 对象 p1Person p2=new Person();/声明并实例化一 Person 对象 p2p1.name=“张三“;/给 p1 的属性赋值p1.age=25;p2.name=“李四“;/给 p2 的属性赋值p2.age=30
4、;p1.talk();/分别用 p1、p2 调用 talk()方法p2.talk();例 3：类的封装性public class TestPersonDemo3 public static void main(String args)Persons p = new Persons();/声明并实例化一 Person 对象 pp.name=“张三“;/给 p 中的属性赋值p.age=-25;/在这里将 p 对象中的年龄赋值为-25 岁p.talk();/调用 Person 类中的 talk()方法class PersonsString name;int age;void talk()System
5、.out.println(“我是：“+name+“，今年：“+age+“岁“);修改：public class TestPersonDemo2 public static void main(String args)Persons p = new Persons();/声明并实例化一 Person 对象 pp.name=“张三“;/给 p 中的属性赋值p.age=-25;/在这里将 p 对象中的年龄赋值为-25 岁p.talk();/调用 Person 类中的 talk()方法class Personsprivate String name;private int age;void talk(
6、)System.out.println(“我是：“+name+“，今年：“+age+“岁“);修改：class Personprivate String name;private int age;void talk()System.out.println(“我是：“+name+“，今年：“+age+“岁“);public void setName(String str)name=str;public void setAge(int a)if(a0)age=a;public String getName()return name;public int getAge()return age;pub
7、lic class TestPersonDemo4public static void main(String args)Person p=new Person();p.setName(“张三“);p.setAge(-25);p.talk();注：1、 在程序中加入一些 setXxx()、getXxx()方法，主要用来设置和取得类中的私有属性。2、 封装类中的属性或方法：封装属性：private 属性类型 属性名封装方法：private 方法返回类型 方法名称（参数）3、用 private 声明的属性或方法只能在其类的内部被调用，而不能在类的外部被调用，可先暂时简单理解为，在类的外部不能用对象
8、去调用 private 声明的属性或方法。修改：将 talk()方法封装起来class Personprivate String name;private int age;private void talk()System.out.println(“我是：“+name+“,今年：“+age+“岁“);public void setName(String str)name=str;public void setAge(int a)if(a0)age=a;public String getName()return name;public int getAge()return age;public
9、class TestPersonDemo5public static void main(String args)Person p=new Person();/声明并实例化一 Person 对象 pp.setName(“张三“);/给 p 中的属性赋值p.setAge(-25);/在这里将 p 对象中的年龄赋值为-25 岁p.talk();/调用 Person 类中的 talk()方法注：private 也同样可以用来声明方法的，这样这个方法就只能在类的内部被访问了。修改：class Personprivate String name;private int age;private void
10、talk()System.out.println(“我是：“+name+“,今年：“+age+“岁“);public void say()talk();/用于调用类内部的私有方法 talk（） 。public void setName(String str)name=str;public void setAge(int a)if(a0)age=a;public String getName()return name;public int getAge()return age;public class TestPersonDemo6public static void main(String a
11、rgs)Person p=new Person();/声明并实例化一 Person 对象 pp.setName(“张三“);/ 给 p 中的属性赋值p.setAge(30);/在这里将 p 对象中的年龄属性赋值为 30 岁p.say();/调用 Person 类中的 say()方法注：这时 say()方法调用 talk()方法，如果非要强调对象本身的话，也可以写成如下形式：this.talk();例 3：引用数据类型的传递class PersonString name;int age;public class TestRefDemo1public static void main(String
12、 args)Person p1=null;/声明一对象 p1，此对象的值为 null,表示未实例化Person p2=null;/声明一对象 p2，此对象的值为 null，表示未实例化p1=new Person();/实例化 p1 对象p1.name=“张三“;/ 为 p1 对象中的属性赋值p1.age=25;p2=p1;/将 p1 的引用赋给 p2，此时相当于 p1 与 p2 都同时指向同一块堆内存System.out.println(“姓名：“+p2.name);/输出 p2 对象中的属性System.out.println(“年龄：“+p2.age);p1=null;/把 p1 对象赋值
13、为 null，表示此对象不再引用任何内存空间说明：程序执行到最后一句时，实际上 p1 断开了对其之前实例化对象的引用，而 p2 则继续指向p1 原先的引用。这道程序中 p2 是通过 p1 对象实例化的，或者说 p1 将其自身的引用传递给了 p2。注意：如果在程序最后又加了一段代码，令 p2=null，则之前由 p1 创建的实例化对象不再有任何对象使用它，则此对象称为垃圾对象。所谓垃圾对象，就是指程序中不再使用的对象引用。例 4：class Changeint x=0;/声明一名为 Change 的类，里面有一个属性 xpublic class TestRefDemo2public static
14、 void main(String args)Change c=new Change();/实例化一个 Change 类的对象 cc.x=20;/将对象 c 中的 x 属性赋值为 20fun(c);/调用 fun()方法，将对象 c 传递到方法之中System.out.println(“x=“+c.x);public static void fun(Change c1)c1.x=25;/将对象 c1 中的 x 属性赋值为 25/声明这个 fun 方法，接收参数类型为 Change 类型说明：fun()方法接收的参数是 Change c1，也就是说 fun()方法接收的是一个对象的引用，所以在f
15、un 方法中所做的操作，是会影响原先的参数。从下图可以发现，最开始声明的对象 c 将其内部的 x 赋值为 20（图 A） ，之后调用 fun()方法，将对象赋值给 c1，c1 再继续修改 x 的值，此时 c1 与 c 同时指向同一内存空间，所以c1 操作了 x 也就相当于 c 操作了 x，所以 fun()方法执行完毕之后，x 的值为 25.例 5：匿名对象：没有明确的声明的对象。即可理解为只使用一次的对象，即没有任何一个具体的对象名称引用它。class Personprivate String name=“张三“;private int age=25;public String talk()r
16、eturn“我是：“+name+“，今年：“+age+“岁“;/声明了一 Person 类，里面有 name 和 age 两个私有属性，并分别赋了初值。public class TestNoNamepublic static void main(String args)System.out.println(new Person().talk();/声明了一 Person 匿名对象，调用 Person类中的 talk()方法。注：由程序中可以发现用 new Person()声明的对象并没有赋给任何一个 Person 类对象的引用，所以此对象只使用了一次，之后就会被 java 的垃圾收集器回收。例
17、 6：构造方法：在 java 程序里，构造方法所完成的主要工作是帮助新创建的对象赋初值。构造方法可视为一种特殊的方法，它定义与普通方法类似。调用时机：一般的方法是在需要时才调用，而构造方法则是在创建对象时，便自动调用，并执行构造方法的内容。因此，构造方法无需在程序中直接调用，而是在对象产生时自动执行。利用构造方法的特性，可利用它来对对象的数据成员做初始化的赋值，所谓初始化就是为对象赋初值。class Person/声明 Person 类public Person()/Person 类的构造方法System.out.println(“public Person()“);public class
18、TestConstructpublic static void main(String args)Person p=new Person(); /实例化一个 Person 类的对象 p，此时会自动调用Person 中的无参构造方法，即在屏幕上打印信息。注：实际上，在执行 javac 编译 java 程序时，如果在程序中没有明确声明一个构造方法的话，系统会自动为类加入一个无参的且什么都不做的构造方法。类似于：public Person()所以之前所使用的程序虽然没有明确的声明构造方法，也是可以正常运行的。例 7：构造方法的重载：只要构造方法的参数个数不同，或是类型不同，便可定义多个名称相同的构造
19、方法。class Personprivate String name;private int age;public Person(String n,int a)/在 Person 类中声明一各含有两个参数的构造方法，此构造方法用于将传入的值赋给 Person 类的属性name=n;age=a;System.out.println(“public Person(String n,int a)“);public String talk()return“我是：“+name+“，今年：“+age+“岁“; /声明一个 Person 类，里面有 name 与 age 两个私有属性和一个 talk()方法
20、public class TestConstruct1public static void main(String args)Person p=new Person(“张三“,25);/调用 Person 类中有的含有两个参数的构造方法（new Person（”张三”,25） ） ，同时将姓名和年龄传到类里，分别为各个属性赋值。System.out.println(p.talk();/调用 Person 类中的 talk()方法，打印信息。注：从本程序可发现，构造方法的基本作用就是为类中的属性初始化的，在程序产生类的实例对象时，将需要的参数由构造方法传入，之后再由构造方法为其内部的属性进行初始
21、化。例 8：class Personprivate String name;private int age;public Person(String n,int a) name=n;age=a;System.out.println(“public Person(String n,int a)“); public String talk()return“我是：“+name+“，今年：“+age+“岁“;public class TestConstruct2public static void main(String args)Person p=new Person();System.out.pr
22、intln(p.talk();修改：class Personprivate String name;private int age;public Person()public Person(String n,int a) name=n;age=a;System.out.println(“public Person(String n,int a)“); public String talk()return“我是：“+name+“，今年：“+age+“岁“;public class TestConstruct2public static void main(String args)Person p
23、=new Person();System.out.println(p.talk();例 9：对象的比较：有两种方式可用于对象间的比较，它们是“=”运算符与 equals()方法。“=”操作符用于比较两个对象的内存地址值是否相等，equals()方法用于比较两个对象的内容是否一致。public class TestEqualspublic static void main(String args)String str1=new String(“java“);String str2=new String(“java“);String str3=str2;if(str1=str2)System.ou
24、t.println(“str1=str2“);elseSystem.out.println(“str1!=str2“);if(str2=str3)System.out.println(“str2=str3“);elseSystem.out.println(“str2!=str3“); 修改：public class TestEquals1public static void main(String args)String str1=new String(“java“);String str2=new String(“java“);String str3=str2;if(str1.equals(
25、str2)System.out.println(“str1 equals str2“);elseSystem.out.println(“str1 not equals str2“);if(str2.equals(str3)System.out.println(“str2 equals str3“);elseSystem.out.println(“str2 not equals str3“); 注：equals 是 String 类中的方法， 记住：“=”是比较内存地址值的， “equals”是比较内容的。例 10：比较 String 对象的两种声明方式的不同String str1=new St
26、ring(“java”);String str2=”java”;程序：public class StringDemopublic static void main(String args)String str1=“java“;String str2=new String(“java“);String str3=“java“;System.out.println(“str1=str2?-“+(str1=str2);System.out.println(“str1=str3?-“+(str1=str3);System.out.println(“str3=str2?-“+(str3=str2);由程
27、序输出结果可发现：str1 与 str3 相等，则证明 str1 与 str3 是指向同一个内存空间的。可用图来说明：由图可看出：“java”这个字符串在内存中开辟的一个空间，而 str1 与 str3 又同时指向同一个内存空间，所以即使 str1 与 str3 虽然是分两次声明的，但最终却都指向了同一内存空间，而 str2 是用 new 关键字来开辟的空间，所以独占有自己的一个内存空间。注意：String 对象的内容一旦声明则不能轻易改变，如果想改变一个 String 对象的值，则第一步要做的是先将原有的 String 引用断开，之后再开辟新的内存空间，而且如果用 new 关键字开辟 Str
28、ing 对象的内存空间的话，则实际上就开辟了两个内存空间，如下图：例 11：this 关键字的使用this 强调对象本身，this 表示当前对象，而所谓的当前对象就是指调用类中方法或属性的那个对象。修改：此时的 this.name 和 this.age 就分别代表类中的 name 与 age 属性，这时再完成赋值操作的话，就可以清楚知道谁赋值给谁了。程序：class Person private String name;private int age;public Person(String name,int age)/声明 Person 类的一个构造方法，此构造方法的作用是为类中的属性赋初值
29、this.name=name;this.age=age;public String talk()return“我是：“+name+“,今年：“+age+“岁“;/声明一个名为 Person 的类public class TestJavaThispublic static void main(String args)Person p=new Person(“张三“,25);System.out.println(p.talk();运行结果：例 12：判断两个对象是否相等（假设只要姓名、年龄相同就为同一人）class PersonString name;int age;Person(String n
30、ame,int age)this.name=name;this.age=age;boolean compare(Person p)if(this.name.equals(p.name)elsereturn false;/声明了一个 compare 方法，此方法接收 Person 实例对象的引用/声明了一个名为 Person 的类，里面有一个构造方法与一个比较方法public class TestComparepublic static void main(String args)Person p1=new Person(“张三“,30);Person p2=new Person(“张三“,30
31、);System.out.println(pare(p2)?“相等，是同一人！“:“不相等，不是同一人！“);/由 p1 调用 compare()方法，将 p2 传入到 compare 方法之中例 13：用 this 调用构造方法如果想在程序中用某一构造方法调用另一构造方法，可以用 this 来实现，具体的调用形式如下：this();程序：class PersonString name;int age;public Person()System.out.println(“1.public Person()“);public Person(String name,int age)this();/
32、调用本类中无参构造方法this.name=name;this.age=age;System.out.println(“2.public Person(String name,int age)“);/声明 Person 类，类中声明了一个无参、一个有参这样两个构造方法public class TestJavaThis1public static void main(String args)new Person(“张三“,25);/声明一 Person 类的匿名对象，调用了有参的构造方法注：使用 this 调用构造方法必须也只能放在构造方法的第一行。如下：class PersonString na
33、me;int age;public Person()System.out.println(“1.public Person()“);public Person(String name,int age) this.name=name;this.age=age;this();/用 this 调用构造方法，此时不是放在构造方法的首行System.out.println(“2.public Person(String name,int age)“);public String talk() this();System.out.println(“我是：“+name+“，今年：“+age+“岁“);pub
34、lic class TestJavaThis1-1public static void main(String args)new Person(“张三“,25);static 关键字的使用例 14：静态变量：在程序中如果用 static 声明变量的话，则此变量称为静态变量。class Person String name;String city;int age;public Person(String name,int age,String city)/声明 Person 类的一个构造方法，此构造方法分别为各属性赋值this.name=name;this.city=city;this.age=
35、age;public String talk()/声明一 talk()方法，此方法用于返回用户信息return“我是：“+this.name+“, 今年“+this.age+“ 岁，来自：“+this.city;/声明一个名为 Person 的类，含有三个属性：name、age、citypublic class TestStaticDemo1public static void main(String args)Person p1=new Person(“张三“,25,“中国“);Person p2=new Person(“李四“,30,“中国“);Person p3=new Person(“
36、王五“,36,“中国“);/实例化三个 Person 对象System.out.println(p1.talk();System.out.println(p2.talk();System.out.println(p3.talk();/分别调用类中的 talk()方法，输出用户信息注：在 java 中提供了 static 关键字，用它来修饰类的属性后，则此属性就是公共属性了。例 15：class Person String name;static String city=“中国“;int age;public Person(String name,int age)/声明 Person 类的一个构
37、造方法，此构造方法作用是分别为 name、age 属性赋值this.name=name;this.age=age;public String talk()/声明一 talk()方法，此方法用于返回用户信息return“我是：“+this.name+“, 今年:“+this.age+“岁，来自：“+this.city;/声明一个名为 Person 的类，含有三个属性：name、age、city，其中 city 为 static 类型public class TestStaticDemo2public static void main(String args)Person p1=new Perso
38、n(“张三“,25);Person p2=new Person(“李四“,30);Person p3=new Person(“王五“,36);/实例化三个 Person 对象System.out.println(“修改之前信息：“+p1.talk();System.out.println(“修改之前信息：“+p2.talk();System.out.println(“修改之前信息：“+p3.talk();/调用类中的 talk()方法，输出用户信息System.out.println(“*修改之后信息*“);/修改后的信息p1.city=“美国“;/修改了 p1 中的 city 属性Syste
39、m.out.println(“修改之后信息：“+p1.talk();System.out.println(“修改之后信息：“+p2.talk();System.out.println(“修改之后信息：“+p3.talk();在图中，所有的对象都指向同一个 city 属性，只要当中有一个对象修改了 city 属性的内容，则所有对象都会被同时修改。用 static 方式声明的属性，也可以用类名直接访问，以上面的程序来说，要想修改 city属性中的内容，可以用如下方式：Person.city=”美国”;有些书也把 static 类型声明的变量，称之为“类变量” 。例 16：小提示：Static 类型
40、的变量是所有对象共享的内存空间，也就是说无论最终有多少个对象产生，也都只有一个 static 类型的属性，那用它来计算类到底产生了多少个实例对象，可以在构造方法中加入一些记数操作，如下面的程序：class Person static int count=0;/声明一 static 类型的整型变量public Person()count+;/增加了一个对象System.out.println(“产生了：“+count+“个对象！“);public class TestStaticDemo3public static void main(String args)new Person();new P
41、erson();例 17：静态方法：static 既可以在声明变量时使用，也可以用其来声明方法，用它声明的方法有时也被称为“类方法” 。class PersonString name;private static String city=“中国“;int age;public Person(String name,int age)this.name=name;this.age=age;public String talk()return“我是“+this.name+“, 今年：“+this.age+“ 岁，来自：“+city;public static void setCity(String
42、c)city=c;/声明一个 static 类型的方法，此方法也可以用类名直接调用，用于修改 city 属性的内容。/声明一个名为 Person 的类，类中含有一个 static 类型的变量 city，并对此对象进行了封装public class TestStaticDemo4public static void main(String args)Person p1=new Person(“张三“,26);Person p2=new Person(“李四“,25);Person p3=new Person(“王五“,30);System.out.println(“修改之前信息：“+p1.tal
43、k();System.out.println(“修改之前信息：“+p2.talk();System.out.println(“修改之前信息：“+p3.talk();System.out.println(“*修改之后信息*“);Person.setCity(“美国“);/Person 调用 setCity（）方法，对 city 的内容进行修改System.out.println(“修改之后信息：“+p1.talk();System.out.println(“修改之后信息：“+p2.talk();System.out.println(“修改之后信息：“+p3.talk();注：在使用 static
44、 类型声明的方法时需要注意的是：如果在类中声明了一 static 类型的属性，则此属性既可以在非 static 类型的方法中使用，也可以在 static 类型的方法中使用，但用static 类型的属性调用非 static 类型的属性时，则会出现错误。例 18：public class PersonStaticString name=“张三“;static String city=“中国“;int age;public PersonStatic(String name,int age)this.name=name;this.age=age;public static void print()Sy
45、stem.out.println(name);public String talk()return“我是：“+this.name+“ ，今年：“+this.age+“ 岁，来自：“+city; 可以发现，程序中 print()方法是 static 类型的，而 name 属性是非 static 类型的，所以print 在调用非 static 类型的 name 属性时就出现了错误。例 19：理解 main()方法一个类要被 java 解释器直接装载运行，这个类中必须有 main()方法。由于 java 虚拟机需要调用类的 main()方法，所以该方法的访问权限必须是 public，又因为 java
46、 虚拟机在执行 main()方法时不必创建对象，所以该方法必须是 static 的，该方法接受一个 String 类型的数组参数，该数组中保存执行 java 命令时传递给所运行的类的参数。向 java 中传递参数可用如下的命令：java 类名称 参数 1 参数 2 参数 3public class TestMain/*public:表示公共方法static：表示此方法为一静态方法，可以由类名直接调用void:表示此方法无返回值main:系统定义的方法名称String args:接受运行时参数*/public static void main(String args)/取得输入参数的长度 ain
47、t j=args.length;if(j!=2)/判断输入参数的个数是否为两个参数，如果不是，则退出程序System.out.println(“输入参数个数有错误！“);/退出程序System.exit(1);for(int i=0;iargs.length;i+)System.out.println(argsi); 注：所有的接收的参数都被存放在 args字符串数组之中，用 for 循环输出全部内容。例 20：静态代码块：一个类可以使用不包含在任何方法体中的静态代码块，当类被载入时，静态代码块被执行，且只执行一次，静态代码块经常用来进行类属性的初始化。class Personpublic Person()System.out.println(“1.public Person()“);/此段代码会首先被执行
