一.单元概述
类的定义和对象的使用是运用Java语言进行程序设计的核心，本章将对其进行探讨。通过本章的学习应该能够了解Java语言的类和对象的概念，掌握如何定义类，能够应用类来创建对象，掌握对象的方法和属性的使用，掌握常用的关键字，并能解决简单的实际应用问题。
二、教学重点与难点
重点：
（1） 类的定义
（2） 对象的创建和使用
（3） 构造方法
（4） 使用对象
（5） 变量的作用域
（6） this关键字
难点：
（1） 构造方法
（2） 匿名对象
（3） 垃圾回收机制
6.1类的定义
6.1.1什么是类
把相似的对象划归成一个类。 在软件设计中，类就是一个模板，它定义了通用于一个特定种类的所有对象的属性（变量）和行为（方法），如下图6.4所示。
图6.4类的抽象
上图中左侧定义了一个名为light的类，用来表示“灯”，这个类是模板，可以表示图中右侧的灯泡、灯管、节能灯、台灯、吊灯和路灯，这些灯都有共同的属性和方法，因此可以抽象为一个类。
6.1.2类的格式
在Java里的类分为两种：系统类和自定义类。
系统类就是Java自带的标准类，安装JDK后，在lib目录下，就保存了一些基本的类库，还有一些可以从网上下载。比如前面接触过的System，String，BufferReader等，都是系统类。用户对这些类了解的越多，就越方便用户直接使用这些类来编写程序，而不需要从头编写，这样就提高了编码的效率和质量。
那么如何编写自定义类呢？下面就开始学习如何编写！ 首先来学习类的结构，类的定义使用class关键字，具体结构如下：
[public][abstract|final]class 类名[extends父类][implements接口列表]{属性声明及初始化；方法声明及方法体；}
在类的结构中，关键字class之前出现了多个修饰符，这里的修饰符的作用是用来限定类的使用方式。其中：
- public：表明此类为公有类
- abstract：指明此类为抽象类
- final：指明此类为终结类
6.1.3类的成员
类的属性描述一个类的一些可描述的特性，比如人的姓名、年龄、性别等。属性声明的语法结构为：
类的方法用来描述类的动作或活动。
编写职员类，类的结构如下图所示。
职员类的结构
按照Java语言的语法编写出的职员类的代码如下图所示。
Employee的编写
6.2对象的创建和使用
6.2.1什么是对象
- 类(class) — 是对某一类事物的描述
- 对象(object) — 是实际存在的某类事物的个体，也称为实例(instance)
- 类是创建对象的模板，对象是类的实例，如下图所示。
Employee的对象
类是定义一个对象的数据和方法的蓝本。对象是类的实例，可以从一个类中创建许多实例（对象）。创建一个实例的过程成为实例化。
类和对象的关系可以通过下图体现。
类和对象的关系
在Java里，定义一个类，也就是说明一个类型，比如人，这个类Person，一定要实例化成对象后，才可以和它打交道，也就是访问或调用或发送消息。（不过也有特例的情况，这个先不讲，就当没有特例，要记住定义好的类，一定要经过实例化成对象后，对对象进行访问和调用）。比如说要和一个人说话，首先实例化Person这个类，实例对象叫xiaoliu，你就可以跟xiaoliu交流了，访问他的属性或方法，比如他的性别、他的名字、他的身高、他是否handsome，如下图所示。
类实例化为对象
例:定义Person类
public class Person {String name;double high;public void getInfo() {System.out.println("The person's name is " + name + " and high is " + high);}}
6.2.2构造方法
要学习Java语言，必须理解构造方法（Constructor）。构造方法是一种特殊的方法，利用构造方法能够初始化对象的属性，构造方法必须与定义它的类有完全相同的名字。 每次在创建实例变量时，对类中的所有变量都要初始化是很乏味的。如果能够在创建对象的同时就对所有属性都进行了初始化就方便多了，这种自动的初始化是通过使用构造方法来完成的。
构造方法的结构如下：
[修饰符] 类名（参数列表）{//方法体}
构造方法的特点如下：
- 具有与类相同的名称
- 不含返回值类型
- 不能在方法中用return语句返回一个值
- 一般访问权限为public
在一个类中，具有上述特征的方法就是构造方法。 使用构造方法来完成对属性的初始化。
例: 在员工类中加入构造方法
class Employee {String name;int age;double salary;Employee(String _name, int _age, double _salary) {name = _name;age = _age;salary = _salary;}Employee(String _name, int age) {name = _name;}Employee(int _age, String _sex) {age = _age;}public String showName() {System.out.println(name);return name;}public int showAge() {System.out.println(age);return age;}public void updateName(String name2) {name = name2;}public void getSalary() {System.out.println("The salary of this month is 2000");}}
通过实例Employee，可以看到使用带参数的构造方法进行实例化简化了代码，在创建对象的同时给对象的属性赋值。此时，类由一个抽象的蓝图变化为一个具体的对象，同时对象的属性已经赋值。通过多次调用构造方法，一个类可以实例化出多个对象。
构造方法也是方法，但是它是特殊的方法而已。它也可以像普通方法一样发生重载。通常一个类中不止一个构造方法，而是有多个不同参数的构造方法，用户可以根据需要选择不同的构造方法创建对象。
注意在开发中，我们在编写自己的类时，应该根据需要提供相应的构造方法，保证在使用这个类时，能够选择到合适的构造方法。
所有的对象都是通过构造方法来创建的，也可以说任何对象都是通过内存分配操作符new 创建和开辟内存空间的。如果在开发时，没有明确的写出构造方法，在编译时编译器会发现该类没有构造方法，这时编译器会自动的给这个类增加一个构造方法，该构造方法没有任何参数，我们称之为“默认的空构造方法”。相反，如果我们在编写时，手写了一个或是若干个带参的构造方法，那么，这个不带参的空构造方法就不会再自动产生并存在。在这样的情况下，如果在某些情况下还想使用这样的无参数默认构造方法的话，最好还是养成手写出这个无参数的构造方法来，以备后用。否则在这个类中，将不再存在这个默认的构造方法。
构造方法和普通方法的区别如下：
- 作用不同 构造方法是为了创建一个类的实例。这个过程只可以在创建一个对象的时候用到。普通方法的作用是为了完成一段业务功能。
- 修饰符不同 和普通方法一样，构造方法可以有任何访问的修饰：public，protected，private或者没有修饰。不同于普通方法的是，构造方法不能有以下非访问性质的修饰：abstract，final， native，static或者synchronized。
- 返回值不同 返回类型也是非常重要的。普通方法能返回任何类型的值或者无返回值（void），构造方法没有返回值，也不需要void。
- 命名不同 构造方法使用和类相同的名字，而普通方法则不同。按照习惯，普通方法通常用小写字母开始，而构造方法通常用大写字母开始。构造方法通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作
构造方法和普通方法对比如下图所示。
构造方法和普通方法对比图
Java中，每个类都至少要有一个构造方法，如果程序员没有在类里定义构造方法，系统会自动为这个类产生一个默认的访问权限为public且参数列表为空的构造方法。 一旦编程者为该类定义了构造方法，系统就不再提供默认的构造，默认的构造方法形式如下图6.11所示。 图6.11默认构造方法的形式 
例:定义带构造方法的Person类
public class Person {String name;int age;String sex;//计算器static int count = 0;/** 有参的构造方法*/public Person(String _name, int _age, String _sex) {count++;name = _name;age = _age;sex = _sex;}public Person() {count++;}public void getInfo() {System.out.println("The person's name is " + name + ",age is " + age+ " and the sex is " + sex);}public void sayHello() {System.out.println(count + ",Hello everybody");}}
提示：
- 如果类里没有构造方法，系统会默认有一个无参的什么也不做的构造方法；
- 如果类里定义了有参的构造方法，则默认的无参的构造方法就不存在了；
构造方法是实例化对象时才能调用，不能随意调用，实例化对象我们将在后面讲解。
6.2.3 创建对象
声明对象 类定义了一类对象的特性，每一个对象都是相应类的实例。定义一个类后，就可以定义对象了，首先要声明对象，声明对象的语法结构如下：
类名 对象名;
例如：Employee e1;
对象的声明并没有创建对象，只是简单的把对象和类联系起来，使对象成为该类的一个实例。但是创建一个基本数据类型的变量如下：
int i ;
这条语句创建了一个变量并为该变量i分配了适当的内存空间。
创建对象 要为对象分配内存空间，还需要创建对象，这时就要使用new关键字，创建对象的语法结构如下：
对象名 = new 构造方法名(参数列表); 例如： e1= new Employee(); 或者 e2=new Employee(“小明”,29,3000);- 声明并创建对象 对象的声明和创建可以一步完成
声明并创建对象的语法结构如下图所示。
类实例化为对象
- 对象的使用 在对象创建后，就可以使用对象了，可以访问对象的属性和方法。格式为：
对象名.属性名； 对象名.方法名（实际参数表）；
例:使用 Employee创建对象Obama和Hillary，访问对象Obama和Hillary的属性和方法，访问的方式如下所示：
public class TestEmployee {public static void main(String args[]){Employee Obama = new Employee("Barack.Hussein.Obama",48,25000.0);Employee Hillary = new Employee("Hillary Rodham Clinton",62,15000.0);Obama.showName();Obama.getSalary();Hillary.showName();Hillary.getSalary();}}
程序运行结果如下图所示。
TestEmployee的运行结果
例：使用Person的构造方法创建对象
public class PersonTest {public static void main(String args[]){Person p1 = new Person();Person p2 = new Person("kitty",5,"female");Person p3 = new Person();Person p4 = new Person();System.out.println(p2.name);System.out.println(Person.count);System.out.println(p1.count);}}
运行结果如下图所示。
PersonTest的运行结果
6.2.4对象创建内存模型
对象创建的内存模型
- 在java中所有的变量、数组、对象都是分配在内存中的，根据变量类型的不同分配的内存也有所不同。
- 内存的类别
- 栈stack：栈的存取速度比堆快，效率高。在栈内保存基本数据类型的局部变量和对象的引用值。
- 堆heap：堆可以保存那些对空间要求较大的变量。如对象的属性和数组的元素。在堆内存中开辟空间，只能通过内存分配操作符号new，凡是出现关键字new的地方必定分配了一个堆内存。
- •我们在实例化一个对象时，同时操作了栈内存和堆内存。在栈内保存对象的首地址，即引用；在堆内存中保存了对象的属性。对对象的所有操作只能通过引用完成，一旦引用出栈释放没有任何引用指向该对象，对象就变成垃圾失效。
除了8种基本数据类型的变量，其他变量都是引用类型变量。
引用类型变量的定义如下图所示。
引用类型的定义
定义Person对象的内存模型如下图所示。
定义Person对象的内存模型示意图
定义两个Person对象的内存模型如下图所示。
定义两个Person对象的内存模型示意图
如上所示，对象的属性name 、age、sex都分配在堆内存中，但是对象名 p、q都分配在栈内存中。p 、q也称为对象的引用(reference)，引用在java中是地址的同义词。
访问对象：在其他类中或main方法中，若想访问对象的属性或是方法必须先实例化这个类，然后通过对象名（引用）和点操作符来完成： 对象名. 属性名； 对象名. 方法名（）；
如果在类内的方法中，访问本类的属性和方法就可以直接访问了。
6.2.5 匿名对象
创建完对象，在调用该对象的方法时，也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫匿名对象，非匿名和匿名对象的对比如下图所示。
非匿名和匿名对象的对比
使用匿名对象的情况，如果对一个对象只需要进行一次方法调用，Java的垃圾回收机制是自动的，它保证程序健壮的主要手段，同时也避免了回收内存带来的代码繁琐。
垃圾回收机制实际上是JVM内部运行的一个优先级比较低的后台线程，这种多线程的模式使得java 具有更好的性能，完全不用程序员参与。垃圾回收机制仅仅作用于堆内存，于栈内存无关。对于程序员来说，对象何时变成垃圾呢？
对象的引用被赋值为null；
Person p = new Person( );p = null;
一次性使用的匿名对象;
new Person( ).sayHello( );
超出生命周期的；如：
for( int I = 0; i< 100; i++){Person p = new Person( );}
这里，变量p 被实例化100次，每结束一次循环，变量p就超出生命周期，对象变为垃圾，垃圾回收机制如下图所示。
垃圾回收机制
6.2.6 变量的作用域
Java中主要有3种类型的变量：
- 局部变量：定义在方法体中的变量；或是方法的形参。
- 实例变量：即类的属性，也是类内的全局变量。
- 静态变量：在类中声明为static 的属性。
变量有作用域，作用域是指变量在程序中的可使用范围。java程序在基础知识部分就学习了变量，下面来看一下各种类别变量的作用域。
- 类变量：用static修饰的属性，它们在类被载入时创建，只要类存在，static变量就存在
- 实例变量：类体中声明的属性为全局变量，全局变量在类的整个生命周期中都有效。
- 局部变量：方法体中声明的变量，方法中的参数，或代码块中声明的变量，都是局部变量，局部变量只在方法调用的过程中有效，方法调用结束后失效。
下面通过以前学过的例子来看一下各类型的变量的作用域。
- 首先通过Employee这个类来了解实例变量和形参的作用域，在Employee类中有三个实例变量，它们的作用域都是整个类的内部，例如可以在方法showName中应用实例变量name；
- 方法showName中定义的hello和方法updateName中的形参name2都是局部变量，作用域仅仅是所在方法的内部。
实例变量和局部变量的作用域如下图所示。
实例变量和局部变量的作用域
其次，来学习方法内局部变量的作用域。下面是一个使用循环语句求水仙花数的例子，例如在for循环头中定义的循环变量i，其作用域是整个for循环，而在循环内定义的局部变量a、b和c，它们的作用域都是从定义的地方开始，到包含它的块结束。
局部变量的作用域如下图所示。 
方法内局部变量的作用域
类变量只能声明一次，但是在方法内不同的非嵌套块中，可以多次声明名称相同的变量。 如果局部变量和一个类变量同名，那么在局部变量的作用域内类变量被隐藏。
例：变量的作用域。
public class Example {int x = 0;int y = 0;void method() {int x = 1;System.out.println("局部变量 x=" + x);System.out.println("全局变量 y=" + y);public static void main(String[] args) {Example e = new Example();e.method();}}
运行结果如下图所示。
Example的运行结果
由上面的运行结果可以看出实例变量x的值在方法p中被局部变量x的值所隐藏，因此输出x时，指的是局部变量。 如果此时还需要打印实例变量的值怎么办呢？下面的小节可以解答这个问题。 变量初始化的顺序是怎么样的呢？ 首先是隐式赋予变量默认值，其次是属性再次显式赋予初始值，最后通过构造方法体赋予新值。
变量作用域例子。
class PersianCat {boolean sex;int age;String name;String furcolor = "white";char id;// 属性=全局变量=属性=在类体里声明的变量public PersianCat(String name1, int age1) {name = name1;age = age1;}public PersianCat() {}public static void main(String args[]) {PersianCat kaki = new PersianCat("Kaki", 1);System.out.println("This is a " + kaki.sex+ " PersianCat,its'furcolor is " + kaki.furcolor + ",name is "+ kaki.name + ",age is " + kaki.age);PersianCat baby = new PersianCat();System.out.println("This is a " + baby.sex+ " PersianCat,its'furcolor is " + baby.furcolor + ",name is "+ baby.name + ",age is " + baby.age + " " + baby.id);}}
6.3 this关键字
this的用途有两种。
第一种情况是引用实例变量，当方法中的参数与某个实例变量有相同的名字时，这时局部变量（参数）优先，实例变量被隐藏。然而有时为了能够在方法中引用实例变量，就可以使用this区分，由this引用的就是实例变量,没有this引用的就是方法中的局部变量或参数。 this关键字代表对象自身的引用，它是一个引用，指向调用该方法的当前对象，通常在类的方法定义中使用。 this关键字的应用的情况，
- 一是方法中的变量与属性重名时
- 二是在一个构造方法中，调用其它重载的构造方法
- 三是返回当前对象的引用
通过如下例子来学习this的应用，第一种情况方法中的局部变量与属性重名时的应用。
例：使用this引用实例变量。
class Employee {String name;int age;double salary;Employee(String name, int age, double salary) {this.name = name;this.age = age;this.salary = salary;}}
第二种情况是引用构造方法，构造方法的this指向同一个类中不同参数列表的另外一个构造方法，我们看看下面的代码：
例：使用this引用构造方法。
public class Dog {String name;int age;int id;/** 方法中的变量与属性重名*/public Dog(String name) {id++;this.name = name;}public Dog() {}/** 在一个构造方法中，调用其他重载的构造方法*/public Dog(String name, int age) {this(name);this.age = age;}/** 把this作为一个局部变量，它的值是当前对象的引用*/public Dog clone() {id++;return this;}public void print() {System.out.println("it is " + name + " number " + id);}public static void main(String args[]) {Dog wangcai = new Dog("Cai Wang");Dog wangwang = new Dog("Wang Wang");wangcai.print();wangwang.print();Dog wangcai1 = wangcai.clone();wangcai1.print();wangwang.clone().clone().print();}}
在上面的代码中，有3个不同参数列表的构造方法。第一个构造方法，给类的成员name赋值，第三个构造方法，调用第一个构造方法。
提示： 在构造方法中，如果要使用关键字this，那么必须放在第一行，否则会导致一个编译错误。
6.4 类与对象的应用
通过下面的例题练习类的定义和使用类来创建对象。
例: People类的编写和使用。
public class Example1 {public static void main(String args[]) {// 声明对象并分配内存People p1 = new People("张华",20);People p2 = new People("自由职业者", true);People p3 = new People();}}class People {String name, career;boolean sex = true; // true代表女，false代表男int age;double height;public People(String name, int age) {this.name = name;this.age = age;System.out.println("姓名：" + name + " 年龄：" + age);}public People(String career, boolean sex) {this.career = career;this.sex = sex;System.out.println("职业：" + career + " 性别：" + sex);}public People(){System.out.println(sex);}}
上面的例题中定义了People类，包含四个属性，从不同角度定义了三个构造方法，在创建对象时根据用户感兴趣的角度来选择使用哪个构造方法来创建对象。
练习：
编写一个 Java 程序，程序中有一个类 Telephone，Telephone 类中包含有电话品牌、电话号码、通话时间、费率、余额等属性，以及计算话费和显示信息等方法。程序中应包含一个主类来使用Telephone类并显示相应的信息。
代码如下：
public class Example2 {public static void main(String[] args) {Telephone tel;tel = new Telephone("TCL", "8309600", 100);tel.rate = 0.2;tel.dialledTime = 150;tel.display();tel.callCost();tel.recharge(50);}}class Telephone {String brand;String number;double dialledTime;double rate;double balance;public Telephone(String brand, String number, double balance) {this.brand = brand;this.number = number;this.balance = balance;}public void recharge(double cost) {balance = balance + cost;System.out.println("冲值后的余额：" + balance);}public void callCost() {double callcost = dialledTime * rate;balance = balance - callcost;System.out.println("话费：" + callcost);System.out.println("余额：" + balance);}public void display() {System.out.println("电话品牌：" + brand + "电话号码：" + number);System.out.println("通话时间：" + dialledTime + "费率：" + rate);}}
运行结果如下图所示。
【总结与提示】
- 类是对象的模板，对象是类的实例；
- 类有两种成员：属性和方法；
- 构造方法是一种特殊的方法，在创建对象时被调用；
- 可以使用关键字this引用类的成员，包括构造方法；
6.5 课后作业
（一）选择题
- this在程序中代表的是?
A.类的对象
B.属性
C.方法
D.父类
- 设 A为已定义的类名，下列声明并创建A类的对象a的语句中正确的是?
A. A a=new A( );
B.public A a=A( );
C.A a=new class( );
D.a A;
- 下列对构造方法的调用方式的描述中正确的是?
A.使用new调用
B.使用类名调用
C.使用对象名调用
D.调用方法为对象名.方法名()
- 设 X 、Y 均为已定义的类名，下列声明类X的对象x1的语句中正确的是?
A.X x1;
B.X x1= X ( );
C.X x1=new Y( );
D.int X x1;
- 定义类头时，不可能用到的关键字是？
A.class
B.public
C.extends
D.static
- 下面关于类的结构的说法正确的是 ？
A.类只能包含一个构造方法
B.类可以没有属性
C.类只能包含方法
D.类只能包含属性
- 下面哪个关键字在定义类头时用不到？
A.class
B.public
C.extends
D.int
- 下面类的定义中结构正确的是 ？
A.class A
B.class 2A
C.int class A
D.public class A
- 关于java源文件下列说法正确的是？
A.一个java源文件中只能有一个public 修饰的类
B.一个java源文件中只能有一个缺省的类
C.一个java源文件中可以有多个protected修饰的类
D.一个java源文件中可以有多个protected修饰的类
- 有一个类A，以下为其构造方法的声明，其中正确的是？
A.void A(int x)
B.A(int x)
C.a(int x)
D.void a(int x)
- 下列构造方法的调用方式中，正确的是
A.按照一般方法调用
B.由用户直接调用
C.只能通过new自动调用
D.不用调用，自动执行
- 设i , j为类X中定义的double型变量名，下列X类的构造方法中不正确的是?
A.double X(double k )
B.X( )
C.X(double m, double n )
D.X(double k )
- 以下关于构造函数的描述错误的是 ?
A.构造函数的返回类型只能是void型。
B.构造函数是类的一种特殊函数，它的方法名必须与类名相同。
C.构造函数的主要作用是完成对类的对象的初始化工作。
D.一般在创建新对象时，系统会调用构造函数。
- 面向对象程序不包含下面的哪个组成部分？
A.类
B.对象
C.接口
D.程序员
- 下列关于类的定义的选项中，哪些可以通过new Thing()方法来创建该类的一个对象?
A. public class Thing { public Thing() {}}
B. public class Thing { public Thing(void) {} }
C. public class Thing { public Thing() {}}
D. public class Thing { public Thing(String s) {} } }
E. public class Thing { public void Thing(String s) {} }
(二)简答题
- 写出程序的运行结果。
```java
public class C {
public static void main(String args[]) {
} }String s1 = new String("Hello!");String s2 = new String("I love JAVA.");A s = new A(s1, s2);System.out.println(s1 + s2);System.out.println(s.toString());
class A { String s1; String s2;
A(String str1, String str2) {s1 = str1;s2 = str2;str1 = "No pain ,";str2 = "no gain!";System.out.println(str1 + str2);}public String toString() {return s1 + s2;}
}
3. 写出下列程序的输出结果。```javaclass Cruncher {void crunch(int i) {System.out.print("int");}void crunch(String s) {System.out.print("String");}public static void main(String args[]) {Cruncher crun = new Cruncher();char ch = 'p';int c = 12;crun.crunch(ch);System.out.print(";");crun.crunch(c);}}
下面是同学写的Teacher类，请指出其中的错误。
static class Teacher {string name;int age;void Teacher(int n, int a) {name = n;age = a;return age;}}
下面是一个类的定义，请完成程序填空。
public class __ {int x, y;Myclass ( int i, _) // 构造方法 {x=i; y=j;}}
下面方法的功能是判断一个整数是否为偶数，将程序补充完整。
public __ isEven(int a) {if(a%2==0)return _;elsereturn false;}
定义求绝对值的方法abs(),利用方法的重载实现既能求整数的绝对值， 又能求浮点数的绝对值。
- 创建一个Circle类，此类中包括一个半径属性radius和一个计算面积的方法findArea。在main方法中创建Circle类的对象c，并计算半径为5的圆的面积。
- 创建一个Telephone类，属性有电话号码number，还有2个构造方法，其中一个没有参数，一个带参数。
（三）编程题
定义一个点类Point，包含2个成员变量x、y分别表示x和y坐标，2个构造器Point()和Point(int x0,y0),以及一个movePoint（int dx,int dy）方法实现点的位置移动。编写一个程序，创建两个Point对象p1、p2，分别调研movePoint方法后，打印p1和p2的坐标。
定义一个矩形类Rectangle：
1)定义三个方法：getArea()求面积、getPer()求周长，showAll()分别在控制台输出长、宽、面积、周长。
2)有2个属性：长length、宽width
3)通过构造方法Rectangle(int width, int length)，分别给两个属性赋值
- 定义一个笔记本类，该类有颜色（char）和cpu型号（int）两个属性。
(1)无参和有参的两个构造方法；有参构造方法可以在创建对象的同时为每个属性赋值；
(2) 输出笔记本信息的方法
然后编写一个测试类，测试笔记本类的各个方法。
- （1）定义一个人类Person：
1)定义一个方法sayHello()，可以向对方发出问候语“hello,my name is XXX”
2)有三个属性：名字、身高、体重
（2）定义一个PersonCreate类：
1）创建两个对象，分别是zhangsan，33岁，1.73；lishi，44，1.74
2）分别调用对象的sayHello()方法。
- （1）定义一个人类Person：
1)定义一个方法sayHello()，可以向对方发出问候语“hello,my name is XXX”
2)有三个属性：名字、身高、体重
3)通过构造方法，分别给三个属性赋值
（2）定义一个Constructor类：
1）创建两个对象，分别是zhangsan，33岁，1.73；lishi，44，1.74
2）分别调用对象的sayHello()方法。
设计一个类Student，该类包括姓名、学号和成绩。设计一个方法，按照成绩从高到低的顺序输出姓名、学号和成绩信息。
定义一个汽车类Vehicle，要求如下：
（1）属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型），并且所有属性为私有。
（2）至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。
（3）为私有属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。
（4）定义一个一般方法run()，用打印语句描述汽车奔跑的功能
定义测试类VehicleTest，在其main方法中创建一个品牌为“benz”、颜色为“black”的汽车。
[
若有收获，就点个赞吧
0 人点赞
