面向对象编程思想

面向对象编程思想（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)]$

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 );
    }
}

每个对象都有独立的内存区域。如图所示：

注意：直接在类中为属性赋值称为初始化属性，将来创建的每个对象都会拥有相同的属性值。
演示的代码如下：

class Student{                // 学生类
	/ /属性
	String stuId;          // 学生的学号
	String name ="张三";			 // 学生的姓名，在类中为属性赋值（初始化属性）
	int age =18;  	// 学生的年龄，在类中为属性赋值（初始化属性）
	boolean sex;  // 学生的性别
	double score; / / 学生的成绩
}

创建的每个Student对象name属性与age属性都会赋值为张三、18。如图所示：

调用对象中的方法
语法如下：

引用名.方法名( 实参 );

演示的代码如下：

 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），在出口增加安检，保障内部商品与客户的安全。

习题

关方法重载描述错误的是(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默认赋值:用户名[email protected] 
    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;
    }
}