面向对象编程思想（Object Oriented Programming）
- 面向过程编程思想
面向过程核心思想：自顶向下，逐步求精。 - 面向对象编程思想
面向对象核心思想：以对象为单位，将解决客观世界问题的方式方法引入到编程领域中。 面向对象编程是面向过程的一种升级。
1 什么是对象？
- 概念：
由于计算机不断地发展需要计算机解决人类在现实世界中的问题，所以必须在程序中模拟出客观世界存在事物，而对象就是对事物的一种统称 一句话总结：万物皆对象，一切客观存在的事物在面向对象思想中统称为对象。
1.1 对象的组成部分
- 客观存在事物复杂多样，千奇百怪形态各异，但无论什么对象都可以拆分为两部分。
1. 对象所具备的属性：对象有什么，决定了对象的特征。 2. 对象所具备的方法：对象能做什么，决定了对象的行为。
如图所示：
- 程序中的对象
对象的属性，使用变量表示。 对象的方法，使用函数表示。
如图所示：
2 类【重点】
2.1什么是类
- 概念：
类就是对象的模板（设计图），用来描述对象具备的属性（特征），方法（行为）。 JVM类似于工厂，通过类（模板）创建对象（类的实例）。 类是从多个相同类型的对象中抽取出来的共性，只保留程序所关注的部分。
如图所示：
2.2 类的组成部分
- 属性/成员变量/全局变量/实例变量。
定义位置：类以内，方法以外。
演示的代码如下：// 类：对象的模板（设计图），JVM需要通过类创建相同的对象 // 在类中定义对象所具备的属性（特征），方法（行为） // Student类的模板 class Student{//学生类 //属性 String stuId;//学生的学号 String name;//学生的姓名 int age; //学生的年龄 boolean sex;//学生的性别 double score;//学生的成绩 } - 方法/成员方法/实例方法
定义位置：类以内，其他方法以外
语法如下：
演示的代码如下：访问权限修饰符 返回值类型 方法名(参数表) 抛出的异常{ }
演示的代码如下：public void test(){ }class Student{//学生类 //属性 String stuId;//学生的学号 String name;//学生的姓名 int age; //学生的年龄 boolean sex;//学生的性别 double score;//学生的成绩 //方法 public void study(){//学习方法 System.out.println("学习使我快乐"); } public void sayHello(){//打招呼方法 System.out.println("你好！"); } }
3 使用类创建对象【重点】
-
语法如下：
new 类名();演示的代码如下：
new Student();//创建一个学生对象 new Teacher();//创建老师对象 new Product();//创建商品对象注意：创建对象时务必保证有对应的类（.class），否则编译错误。
-
为引用赋值
在Java中每定义一个类，JVM中就多了一种自定义的数据类型，可以将对象保存在相同类型的引用中便于后续使用。
演示的代码如下：Student stu1;//声明学生类型的引用 stu1 = new Student();//创建学生对象 Student stu2 = new Student();//创建对象同时赋值每个对象都代表了客观世界中的一名学生。
-
模板只有一个，通过模板可以创建多个对象，每个对象都有属于自己的一块内存空间。
如图所示：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fILV7hbD-1630915842701)(D:\CoreJava\day8_object_oriented\images\7面向对象_对象独立.png)]](https://img-blog.csdnimg.cn/d5f6959e88d4435c9f32fa822d927fb1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5a2m5peg5q2i6Lev,size_20,color_FFFFFF,t_70,g_se,x_16)
4 使用对象的属性，调用方法【重点】
4.1 使用属性
- 语法如下：
属性也具有默认值，默认值取值规则与数组一致。// 为属性赋值 引用名.属性名 = 值; // 获取属性值 引用名.属性名
演示的代码如下：
package com.txw.test;
public class Test {
public static void main(String args[]) {
Student stu1; // 声明学生类型的引用
stu1 = new Student(); // 创建学生对象
// 为stu1的stuId属性赋值
stu1.stuId = "10000000888";
// 为stu1的name属性赋值
stu1.name = "Adair";
// 为stu1的age属性赋值
stu1.age = 72;
// 为stu1的sex属性赋值
// stu1.sex = "男"; 为属性赋值时注意类型一致
stu1.sex = false; // 男
// 为stu1的score属性赋值
stu1.score = 1.5;
// 打印stu1的stuId属性
System.out.println( stu1.stuId );
// 打印stu1的name属性
System.out.println( stu1.name );
// 打印stu1的age属性
System.out.println( stu1.age );
}
}
每个对象都有独立的内存区域。如图所示： 
- 注意：直接在类中为属性赋值称为初始化属性，将来创建的每个对象都会拥有相同的属性值。
演示的代码如下：
创建的每个Student对象name属性与age属性都会赋值为张三、18。如图所示：class Student{ // 学生类 / /属性 String stuId; // 学生的学号 String name ="张三"; // 学生的姓名，在类中为属性赋值（初始化属性） int age =18; // 学生的年龄，在类中为属性赋值（初始化属性） boolean sex; // 学生的性别 double score; / / 学生的成绩 }
- 调用对象中的方法
语法如下：
演示的代码如下：引用名.方法名( 实参 );
执行流程，,如图所示：public static void main(String[] args) { // 创建对象 Student stu1 = new Student(); // 为属性赋值略.... // 调用stu1的study方法 stu1.study(); // 调用stu1的sayHello方法 stu1.sayHello(); }
- 复杂方法（传入参数，接收返回值）
演示的代码如下：
package com.txw.test;
class Student{ // 学生类
// 属性
String stuId; // 学生的学号
String name ; // 学生的姓名
int age; // 学生的年龄
boolean sex; // 学生的性别
double score; // 学生的成绩
double pinMoney; // 学生的零用钱
// 方法
public void study(){
System.out.println("学习使我快乐");
}
public void sayHello(){
System.out.println("你好！");
}
// 购物方法
// goods：商品
// price：价格
public double shopping(String goods,double price){
System.out.println(name+" 要购买的商品是："+goods);
System.out.println("需支付: "+ price );
pinMoney -= price; // 扣除零用钱
System.out.println("零用钱剩余："+pinMoney);
return price; // 支付对应的金额
}
}
执行流程， 如图所示：
5 局部变量与成员变量的区别
| 局部变量 | 成员变量 | |
|---|---|---|
| 定义位置 | 方法中 | 类以内，方法以外 |
| 默认值 | 必须手动赋值 | 有 |
| 作用范围 | 定义行开始，到所在代码块结束 | 至少在本类中 |
| 命名冲突 | 重合作用范围内，不允许重名 | 可与局部变量重名，局部变量优先 |
演示的代码如下：
class MyClass{
int a; // 属性（成员变量）
public void method(){
int b; // 局部变量
}
public void m1(){
// System.out.println( b ); error超出局部变量的使用范围
System.out.println( a ); // a是成员变量可以使用
}
}
六、方法的重载 Overload【重点】
-
作用：允许在一个类中定义多个同名的方法，屏蔽使用时的差异，使用更加方便。
演示的代码如下：class Calculator{ // 计算器 public void sum(int a,int b){ System.out.println( a + b); } public void sum1(int a, double b){ System.out.println( a + b ); } public void sum2(double a,int b){ System.out.println( a + b ); } public void sum3(double a,double b){ System.out.println( a + b ); } }由于处理的数据类型不同，需要定义不同的方法，如果方法名不同，使用者就要时刻记住什么样的方法能处理什么样的数据，对使用者造成不便。
-
方法重载的语法要求。
方法名相同，参数表不同（个数、类型、顺序）参数名不同不算重载。
演示的代码如下：class MyClass{ public void m1(){ System.out.println("m1()"); } public void m1(int n){ System.out.println("m1(int n)"); } public void m1(int a, int b){ System.out.println("m1(int a, int b)"); } public void m1(String str){ System.out.println("m1(String str)"); } }编译器根据方法名与实参找到对应的方法调用方法。
面向对象编程套路。1. 根据需求定义类（模板、设计图）。 2. 创建对象。 3. 访问对象的属性，调用对象方法。 -
思考
定义一个Account类表示账户 定义属性用户名（username），密码（password），创建时间（createDate），余额（balance） 定义方法取款（withdraw），转账（transfer) 取款方法定义一个double类型的参数，表示取款金额，在方法中打印取款金额 转账方法，打印转账 定义一个测试类，创建一个Account对象，为各个属性赋值，打印各个属性的值 调用取款方法，调用转账方法
7 构造方法【重点】
-
隐藏在类中的方法，每个类至少拥有一个构造方法。
-
可以显式的将构造方法定义到类中。
-
语法如下：
访问权限修饰符 类名(参数表){ } -
特点：
1. 构造方法的方法名必须与类名一致。 2. 没有返回值类型。 3. 不能手动调用。 4. 创建对象时自动调用。 5. 一个类如果没有构造方法，编译器默认提供无参构造方法。 6. 如果一个类定义了构造方法，编译器不再默认提供无参。如图所示：
构造方法支持重载，可以在一个类中定义多个方法名相同，参数表不同的构造方法。
演示的代码如下：class MyClass{ public MyClass(){ // 无参构造方法 System.out.println("MyClass"); } public MyClass(int a) {// 有参构造方法 System.out.println("MyClass(int)"); } public MyClass(int a,int b) {// 有参构造方法 System.out.println("MyClass(int,int)"); } public void m1(){ // 一般方法 System.out.println("m1 in MyClass"); } } // 创建对象时 new MyClass() 用来表明，创建对象时自动调用哪个构造方法 new MyClass(); // 创建对象时自动调用无参构造方法 new MyClass( 10 ); // 创建对象时自动调用有参构造方法 new MyClass(10,20); // 创建对象时自动调用有参构造方法 -
作用：使用构造方法为属性赋值。
步骤：
1. 为类添加有参构造方法，参数个数、类型、顺序与属性一致 2. 使用形参为属性赋值 3. 创建对象时使用有参构造方法，传入对应的实参为形参赋值演示的代码如下：：
class Account{ // 账户类 String username; // 用户名 String password; // 密码 int age; // 年龄 double balance; // 余额 // 1. 为类添加有参构造方法，参数个数、类型、顺序与属性一致 public Account(String a,String b,int c,double d){ // 数据传递：将接收到的数据为属性赋值 // 2.使用形参为属性赋值 username = a; // yangcs password = b; // 123456 age = c; // 18 balance = d; // 599999D; } }
演示的代码如下：
// 利用构造方法为属性赋值
// 3. 创建对象时使用有参构造方法，传入对应的实参为形参赋值
Account ac = new Account("yangcs","123456",18,599999D);
如图所示：
在实际开发环境中通常都会写两个构造方法，一个无参，一个有参。
演示的代码如下：
class Account{ // 账户类
String username; // 用户名
String password; // 密码
int age; // 年龄
double balance; // 余额
public Account(){} // 无参构造方法
// 1.为类添加有参构造方法，参数个数、类型、顺序与属性一致
public Account(String a,String b,int c,double d){
// 数据传递：将接收到的数据为属性赋值
// 2.使用形参为属性赋值
username = a;
password = b;
age = c;
balance = d;
}
}
8 this关键字
- 概念：this关键字表示当前对象的引用。
当前对象：正在使用该类的对象。
演示的代码如下：MyClass mc1 = new MyClass(); System.out.println( mc1 ); // classes.MyClass@15db9742 mc1.m1(); MyClass mc2 = new MyClass(); System.out.println( mc2 ); // classes.MyClass@6d06d69c mc2.m1(); class MyClass{ int a = 10; // mc1.m1(); this: mc1 // mc2.m1(); this: mc2 public void m1(){ / /this表示当前对象的引用， // 哪个对象调用的m1 this就是那个对象 System.out.println( this ); } }
8.1 使用this.访问属性或调用方法
演示的代码如下：
class MyClass{
int a = 10; // 属性
public void method(){
int a = 100; // 局部变量
System.out.println( a ); // 打印局部变量
m1(); // 调用m1方法
System.out.println( this.a ); // 打印a属性
this.m1(); // 调用m1方法
}
public void m1(){ // 方法
System.out.println( "m1 in MyClass ");
}
}
- 使用this.解决局部变量与成员变量命名冲突问题。
演示的代码如下：class Account{ // 账户类 String username; // 用户名 String password; // 密码 int age; // 年龄 double balance;/ / 余额 // 完整的构造方法 public Account(String username,String password,int age,double balance){ // 使用this.明确成员变量（属性） this.username = username; this.password = password; this.age = age; this.balance = balance; } }
8.2 使用this() 提高构造方法的重用性
- this()可以定义在构造方法中的第一行，可以在构造方法执行时调用其他构造方法，提高构造方法的重用性。
语法如下：
演示的代码如下：// 在构造方法中的第一行。 this(); // 调用本类的无参构造方法 this(实参); // 调用本类的有参构造方法class MyClass{ int a; int b; // 无参构造方法 public MyClass(){ // 3000行代码 System.out.println("MyClass()"); } // 有参构造方法 public MyClass(int a){ this(); // 调用本类的无参构造方法 this.a = a; System.out.println("MyClass(int n) "); } // 有参构造方法 public MyClass(int a, int b){ //this(); // 调用本类的无参构造方法 // this.a = a; this( a ); // 调用本类有参构造方法 this.b = b; System.out.println("MyClass(int a, int b)"); } }
9 创建对象的过程
- 过程：
1. 为对象分配空间,属性被赋予默认值。 2. 初始化属性，如果属性后有 = 号赋值语句，则此时完成赋值（初始化）。 3. 调用构造方法，可以通过有参构造再次为属性赋值（常用）。
如图所示：
面向对象的三大特性
1 封装（encapsulation）
-
概念：
尽可能的隐藏对象的内部实现细节，控制用户对对象的访问程度，保障内部的数据安全。演示的代码如下：不安全的设计。
class Account{ // 账户类 String username; // 用户名 String password; // 密码 int age; // 年龄 double balance; // 余额 }
1.1 private 访问权限修饰符
-
修饰符：修饰程序中的各个组件（类、方法、属性…），被修饰的组件拥有不同的特点与权限。
-
private访问权限修饰符特点：
private ：私有的，可以修饰属性、方法、构造方法。 被private修饰的组件只能在本类中使用，对外不可见。演示的代码如下：
class Account{ // 账户类 private String username; // 私有的用户名（只能在本类中使用） private String password; // 密码 private int age; // 年龄 private double balance; // 余额 } public class TestEncapsulation{ public static void main(String[]args){ Account ac = new Account(); // 为属性赋值 // ac.username = "yangcs"; Error // ac.password = "123456"; Error // ac.age = 18; // ac.balance = 59D; //获取属性的值 // System.out.println( ac.username ); // System.out.println( ac.password ); // System.out.println( ac.age ); // System.out.println( ac.balance ); } }过度安全，所有的属性都无法被外部进行访问。
1.2 提供可以访问属性、修改属性的方式
- 提供公开的get用于获取属性
语法如下：public 返回值类型 get属性名(){ return 属性; } // 由于get方法需要将属性的值返回，需要返回值类型与属性类型一致 // get方法注意使用驼峰命名法
演示的代码如下：
class Student{
private String name;
private int age;
private double score;
// 用于获取name属性的get方法
public String getName(){
return name;
}
// 用于获取age属性的get方法
public int getAge(){
return age;
}
// 用于获取score属性的get方法
public double getScore(){
return score;
}
}
- 提供公开的set方法用于设置属性（为属性赋值）。
语法如下：
演示的的代码如下 ：public void set属性名(与属性相同的参数){ this.属性名 = 参数名; }class Student{ private String name; private int age; private double score; // 用于设置name属性的set方法 public void setName(String name){ this.name = name; } // 用于设置age属性的set方法 public void setAge(int age){ this.age = age; } // 用于设置score属性的set方法 public void setScore(double score){ this.score = score; } // 用于获取name属性的get方法 public String getName(){ return name; } // 用于获取age属性的get方法 public int getAge(){ return age; } // 用于获取score属性的get方法 public double getScore(){ return score; } }
3、新的访问形式
-
设置属性。演示的代码如下：
Student stu = new Student(); stu.name = "yangcs"; // 封装前为属性赋值 stu.setName("yangcs"); // 封装后为属性赋值 stu.age = 18; // 封装前为属性赋值 stu.setAge( 18 ); // 封装后为属性赋值 -
获取属性。演示的代码如下：
Student stu = new Student(); stu.name; // 封装前获取属性 stu.getName(); // 封装后获取属性 stu.age // 封装前获取属性 stu.getAge(); // 封装后获取属性
1.3 封装的步骤与意义
- 步骤如下：
1. 私有化每个属性。 2. 为每个属性提供公开的get/set方法。 - 意义
封装后所有对于属性的操作都要通过get/set方法 可以在get/set方法中加入数据验证的代码确保属性的安全，例如： // 用于获取password属性的get方法 public String getPassword(){ return "******"; // 返回password属性的值 } // 用于设置age属性的set方法 public void setAge(int age){ if(age<1) {/ /数据验证 System.out.println("非法的年龄！"); return; } this.age = age; }1. 没有封装：超市门口无人看守，无人管理无法保证客户与商品的安全。 2. 属性私有：封住超市的所有出入口，则安全过度。 3. 提供公开的get/set：为超市设置出口（get）、设置入口（set），在出口增加安检，保障内部商品与客户的安全。
习题
- 下列描述错误的是© .
A. 类是对象的模板。
B. 对象是类的实例。
C. 基于一个类只能创建该类的一个对象。
D. 面向对象是 Java 语言的特点之一。
原因：类相当于模板，一个模板是可以创建n个对象的。 - 下列关于属性描述不正确的是© 。
A. 属性定义在类以内，方法以外 。
B. 属性又称为成员变量。
C. 属性的作用范围从定义开始，到定义它的代码块结束。
D. 属性定义后可以在本类中直接使用 。
原因：属性的作用范围是整个类。 - 关方法重载描述错误的是(B D) 。
A. 方法名相同。
B. 返回值类型相同。
C. 参数列表不同。
D. 参数列表相同。 - 下列和 public void method(){}不能构成方法重载的是(D) 。
A. public void method(double d){} 。
B. public void method(int n){}。
C. public int method(int n){ return 10; }。
D. public int method(){ return 0; }。
原因：重载的要求是，方法名称相同，参数列表不同，与返回值类型和修饰符无关。
5 仔细阅读以下程序，关于程序结果描述正确的是©。
package com.txw.test;
class ClassA{
public void mehod(int value){
System.out.println(value);
}
public void mehod(){
System.out.println(value);
}
int value;
}
public class TestClassA {
public static void main(String [] args) {
ClassA classA = new ClassA();
classA.value = 10;
classA.mehod();
classA.mehod(20);
}
}
A. 编译不通过 。
B. 输出 10 10。
C. 输出 10 20。
D. 输出 0 20 。
6. 下面关于构造方法描述错误的是(BC)。
A. 构造方法的名必须和类名一致。
B. 构造方法没有返回值类型，即声明部分为 void 类型。
C. 一个类中可能不存在任何构造方法。
D. 构造方法可以为属性赋值 。
原因：B选项错误，构造方法是没有返回值类型，void是返回值类型中的一种。 C选项错误，因为类中一定会有构造方法，及时自己不定义，编译器会默认提供一个无参的。
7. 构造方法什么时候会被调用(B)。
A.类定义时。
B. 创建对象时。
C. 调用对象方法时。
D. 使用对象的变量时。
8. 对以下程序描述正确的是(CD)。
class ClassA{
public void ClassA(String str){
System.out.println(str);
}
public void mehod(){
}
}
A. 程序编译报错 。
B. ClassA 类中定义了有参数的构造方法。
C. ClassA 类中只有一个默认的无参数的构造方法。
D. method 方法需要通过对象的调用才能被执行。
原因：public void ClassA(String str){}这不是构造方法，只是一个普通方法， 构造方法没有返回值类型。
9… 仔细阅读以下程序，程序编译是否通过，如果通过写出运行结果；否则说明原因。
package com.txw.test;
class MyClass{
int value;
}
public class TestRef {
public static void main(String [] args) {
int a = 10;
int b = a;
b ++;
System.out.println(a);
MyClass mc1 = new MyClass();
mc1.value = 10;
MyClass mc2 =mc1;
mc2.value ++;
System.out.println(mc1.value);
}
}
答：输出结果10，11。
原因：第一个输出结果是10，因为a的值赋值给b，a和b的值都是10，b++变为11，打印a的值还是10 第二个结果为11，mc1的value属性赋值为10，mc1和mc2指向同一个对象，mc2.value++将对象的value属性变为 11，打印mc1的value也是11。
10. 仔细阅读以下程序，程序编译是否通过，如果通过写出运行结果；否则说明原因。
package com.txw.test;
class ClassA{
int value = 10;
}
public class TestClassA {
public static void main(String [] args) {
ClassA c1 = new ClassA();
changValue(c1);
System.out.println(c1.value);
}
public static void changValue(ClassA c ){
c = new ClassA();
c.value = 30;
}
}
答：输出结果 10 创建c1对象value属性值为10，c1作为实参传递赋值给c，两个引用此时指向同一个对象，但是c引用在方法中进行 了重新赋值，指向了新的对象空间将这个空间中value属性赋值为30，方法调用结束，c引用变为垃圾，程序回到调 用 位置，打印c1的value还是10没有改变。
11. 仔细阅读以下程序，程序编译是否通过，如果通过写出运行结果；否则说明原因。
package com.txw.test;
class ClassA{
public ClassA (){
System.out.println("ClassA()");
}
}
class ClassB{
public ClassB (){
System.out.println("ClassB()");
}
}
class ClassC{
ClassA a = new ClassA();
ClassB b;
public ClassC (){
System.out.println("ClassC()");
b = new ClassB();
}
}
public class TestClassA {
public static void main(String [] args) {
ClassC c = new ClassC();
}
}
答：输出结果：ClassA() ClassC() ClassB()。
12.关于 this 的描述正确的是(AC)。
A. this 代表当前对象。
B. this. 只能应用在构造方法中。
C. this()只能应用在构造方法中。
D. this. 只能放在方法的第一行语句。
13. 编程：定义一个 Dog 类，类中属性有名字、年龄、性别(true-公)，
要求如下：
(1) 提供一个无参数的构造方法和一个带有三个参数的构造方法 。
(2) 类中定义一个无参数的 play 方法：输出 宠物狗。
(3) 类中定义一个带有一个参数的 play 方法，参数类型为 int hours，打印输出玩的小时数。
(4) 定义一个测试类，分别用无参数的构造法和有参数的构造方法创建对象，并对属性赋值，分别 将对象的信息打印在控制台上，调用 play 方法。
演示的代码如下：
package com.txw.test;
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
d.name = "土狗";
d.age = 3;
d.sex = true;
System.out.println(d.name + " " + d.age + " " + d.sex);
d.play(); d.play(10);
Dog d2 = new Dog("哈皮", 4, false);
System.out.println(d2.name + " " + d2.age + " " + d2.sex);
d2.play(); d2.play(20);
}
}
class Dog {
String name; // 姓名
int age; // 年龄
boolean sex; // 性格
public Dog() {
}
public Dog(String name, int age, boolean sex) {
this.name = name; this.age = age; this.sex = sex;
}
public void play() {
System.out.println("宠物狗");
}
public void play(int hours) {
System.out.println("玩" + hours + "个小时");
}
}
- 编程：定义一个交通工具类(Vehicle)，类中属性有商标(brand)、颜色(color)；
要求 如下：
(1) 提供一个无参数的构造方法和有参数的构造方法 。
(2) 功能方法：移动方法(move() )，此方法一旦被调用，控制台显示”我已经启动” 展示信息( showInfo() )，此方法，展示商标和颜色信息。
(3) 定义一个测试类，创建一个交通工具对象，并为属性赋值；将对象的信息打印输出，并调用 对象的方法。
演示的代码如下：
package com.txw.test;
public class Test {
public static void main(String[] args) {
Vehicle v = new Vehicle("劳斯莱斯", "金色");
v.move();
v.showInfo();
}
}
class Vehicle {
String brand; // 商标
String color; // 颜色
public Vehicle(String brand, String color) {
this.brand = brand;
this.color = color;
}
public Vehicle() {
}
// 移动
public void move() {
System.out.println("我已经被启动");
}
// 展示详情
public void showInfo() {
System.out.println(brand + " " + color);
}
}
- 编程：模拟简单的计算器，定义一个类(Number)，类中定义两个整数类型的属性值 1(v1)和值 2(v2)；
(1) 提供两个构造方法，可以为属性赋值。
(2) 提供加( add() )、减( subtration() )、乘( multip() )、除( division() )功能方法。
(3) 定义一个测试类，创建该类对象，并通过调用方法完成两个数值的加、减、乘、除运算。
演示的代码如下：
package com.txw.test;
public class Test{
public static void main(String[] args) {
Number n = new Number(20, 10);
n.add();
n.subtration();
n.multip();
n.divsion();
}
}
// 计算器
class Number {
int v1;
int v2;
public Number() {
super();
// TODO Auto-generated constructor stub
}
public Number(int v1, int v2) {
super();
this.v1 = v1;
this.v2 = v2;
}
// 加法
public void add() {
System.out.println(v1 + v2);
}
// 减法
public void subtration() {
System.out.println(v1 - v2);
}
// 乘法
public void multip() {
System.out.println(v1 * v2);
}
// 除法
public void divsion() {
System.out.println(v1 / v2);
}
}
- 编程：定义一个网络用户类(User 类)，需要处理的信息有用户 ID、用户密码 password、邮箱地址 (email)，要求如下：
(1) 提供带有两个参数的构造方法，为用户 ID 和用户密码赋值，此时 email 采用默认的：用户名 加上”@qqcom.cn”; 同时提供带有三个参数的构造方法。
(2) 定义一个 show 方法，用于展示用户的信息，密码处理为 xxx 。
(3) 定义一个测试类，分别利用不同的构造方法创建对象，并利用方法，展示用户的信息。
演示的代码如下：
package com.txw.test;
public class Test {
public static void main(String[] args) {
User u1 = new User("小明", "woaijava");
User u2 = new User("小红", "wofeichangaijava");
u1.show();
u2.show();
}
}
// 用户类
class User {
String ID;
String passworld; // 密码
String email; // 邮箱
// 两参构造，email默认赋值:用户名+@qq.com.cn
public User(String iD, String passworld) {
super(); ID = iD;
this.passworld = passworld;
email = ID + "@qq.com.cn";
}
public User(String iD, String passworld, String email) {
super();
ID = iD;
this.passworld = passworld;
this.email = email;
}
// 展示用户信息，密码xxx展示
public void show() {
System.out.println("账号: " + ID + ",密码:xxx" + ",邮箱：" + email);
}
}
- 编程：设计一个 Worker 类 和 Address 类，类的要求如下：
(1) 定义一个 Worker 类，类中定义三个属性：姓名、年龄、工资(salary)，要求如下：
① 提供公开无参构造方法和三个参数的构造方法。
② 定义无参的 work 方法和带整数参数 work(int hours)方法，参数代表工人工作的小时数。
(2) 定义一个 Address 类，类中定义属性：地址(addr)、邮编(zipCode)，为此类提供无参数和有 参数的构造方法。
(3) 为 Worker 类添加一个 Address 类型的属性 address (4) 定义一个测试类，创建一个 Worker 对象，其姓名为张三、年龄为 26、工资为 10000.0； 家庭地址为：北京市海淀区清华园 1 号院、邮编为 100010。
演示的代码如下：
package com.txw.test;
public class Test {
public static void main(String args[]) {
Worker w = new Worker("zhangsan", 26, 10000.0);
Address addres = new Address("北京市海淀区清华园1号院", "100010");
w.address = addres;
}
}
// 工人类
class Worker {
String name; // 姓名
int age; // 年龄
double salary; // 工资
Address address; // 地址（属性的类型是Address类型）
public Worker() {
}
public Worker(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public void work() {
System.out.println("work");
}
public void work(int hours) {
System.out.println("worker works for " + hours + " hours");
}
}
// 地址类
class Address {
String address;
String zipCode;
public Address() {
}
public Address(String address, String zipCode) {
this.address = address;
this.zipCode = zipCode;
}
}
总结如图所示：
975
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
