封装 （第14天）

10.1.  封装的特性

1. 面向对象的三大特征：
   封装
   继承
   多态

有了封装，才有继承，有了继承，才能说多态。

2. 封装有什么用:
   保证内部结构的安全。
   屏蔽复杂，暴露简单。
3. 码级别上,封装有什么用:

一个类体当中的数据，假设封装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只 需要通过一个简单的入口就可以访问了。另外，类体中安全级别较高的数据封装起来，外部人员不 能随意访问，来保证数据的安全性。（优点：第一数据安全了。第二调用者也方便了。）

// 这是没有封装的Person。

public class Person{

// 实例变量(属性)

int age; //age属性是暴露的，在外部程序中可以随意访问。导致了不安全。

}

10.2.  封装的步骤

1. 怎么进行封装：

• 属性私有化（使用 关键字进行修饰。）
• 对外提供简单的操作入口。(电视机的遥控器就相当于是电视机的访问入口，简单明了。

• 代码说明：

//尝试封装一下,不再对外暴露复杂的数据，封装起来, 对外只提供简单的操作入口。

public class Person{

// 出了这个类，age属性就无法访问了。私有的。

  private int age; // 每一个人年龄值不同，对象级别的属性。

  // 对外提供简单的访问入口

  // 外部程序只能通过调用以下的代码来完成访问

  // 思考：你应该对外提供几个访问入口?

  // 思考：这些操作入口是否应该是方法呢？

  // 写一个方法专门来完成读。(get)

  // 写一个方法专门来完成写。(set)

  // get和set方法应该带有static，还是不应该有static,get和set方法应该定义为实例方法

  吗？

  // get读年龄，set改年龄，这个读和改都是操作的一个对象的年龄。（没有对象何来年龄）

  public int getAge(){

      return age;

  }

  // set方法

  public void setAge(int nianLing){

  // 能不能在这个位置上设置关卡！！！！

      if(nianLing < 0 || nianLing > 150){

    System.out.println("对不起，年龄值不合法，请重新赋值！");

    return; //直接终止程序的执行。

  }

  //程序能够执行到这里，说明年龄一定是合法的。

    age = nianLing;

  }

}

• 封装的第一步：使用private关键字将实例变量私有化
• private 表示私有的，被这个关键字修饰之后，该数据只能在本类中访问。出了这个类无法访问
• 封装的第二步：对外提供公开的set方法和get方法作为操作入口。 并且都不带 static ，都是实例方法。
  [修饰符列表] 返回值类型 方法名(形式参数列表){
  }

注意：

java开发规范中有要求，set方法和get方法要满足以下格式。

get方法的要求：

  public 返回值类型 get+属性名首字母大写(无参){

  return xxx;

  }

set方法的要求：

  public void set+属性名首字母大写(有1个参数){

  xxx = 参数;

  }

大家尽量按照java规范中要求的格式提供set和get方法。如果不按照这个规范格式来，那么你的

程序将不是一个通用的程序。

10.3.  get方法与set方法的说明

• get 方法与 set 方法都是实例方法
• 不带static的方法称为实例方法，实例方法的调用必须先new对象。
• 一个属性对应一个get、set方法
• get方法用来读（需要将结果输出 需要返回值）、set方法是用来写（修改实例变量的 不需要返回值）
• 有多少个实例变量就可以申明多少个get、set方法
• 可以在set方法中设立关卡来保证数据的安全性。

10.4.  封装步骤总结

• 第一步：属性私有化
• 第二步：1个属性对外提供两个set和get方法。外部程序只能通过set方法修改，只能通过get方法 读取，可以在set方法中设立关卡来保证数据的安全性。

10.5.  初步了解 static 关键字

1. 实例的回顾
   对象被称为实例。
   实例相关的有：实例变量、实例方法。
   实例方法：没有带有 static 的方法称为实例方法
   实例方法是对象相关的方法，对象级别的方法，应该是一个对象级别的行为。实例变量是对象变量,实例方法是对象方法
   实例相关的都需要先new对象，通过“引用.”的方式去访问
2. 实例方法的初步了解

public class MethodTest{

  public static void main(String[] args){

  MethodTest.doSome();

      //类名. 可以省略（在同一个类中。）

      doSome();

      // 创建对象

      MethodTest mt = new MethodTest();

      // 通过"引用.

      "的方式访问实例方法。

      mt.doOther();

   }

  // 带有static

  public static void doSome(){

  System.out.println("do some!");

  }

  //这个方法没有static，这样的方法被称为：实例方法。（对象方法，对象级别的方法）

  //这个没法解释，大家目前死记硬背。

  public void doOther(){

      System.out.println("do other.... ");

  }

}

以上代码的注释：

带 static 的方法与不带 static 的方法的访问：

• 带 static 方法的访问：

• 类名.方法名（实际参数列表）；
• 也可以用“引用."的方式访问,但意义不大。

• 不带 static 的方法的访问：

• 现在类中创建一个该类的对象
• 然后用 引用. 方法名（实际参数列表的方式访问）；

• static修饰的统一都是静态的，都是类相关的，不需要new对象。直接采用“类名.访问''。当一个属性是类级别的属性，所有对象的这个属性的值是一样的，建议定义为静态变量。**

10.6.  实例方法导致的空指针异常

一个实例方法的调用也必须有对象的存在，若 引用为null也会存在NullPointer （空指针异

常）

10.7.  封装中构造方法与set方法的说明

• 代码封装里面的set方法是：创建完成对象后，需要修改值的话调用set
• 有参构造方法是：创建对象时赋值
• 所以两者都要有

10.8.  第十四天作业

• 第一题：设计日期类，每个日期对象都可以描述年月日信息。
• 第二题：设计男人类，每个男人都有身份证号、姓名、性别、女人。设计女人类，每个女人都有身 份证号、姓名、性别、男人。
• 第三题：设计银行账户类，每个账户都有账号、密码、余额等信息。
• 第四题：设计微信账号类，每个微信账号都有微信号、手机号、昵称等信息。第五题：定义丈夫类 Husband 和妻子类 Wife，
  丈夫类的属性包括：身份证号，姓名，出生日期，妻子。
  妻子类的属性包括：身份证号，姓名，出生日期，丈夫。
  分别给这两个类提供构造方法（无参数构造方法和有参数构造方法都要提供）， 编写测试程序，创建丈夫对象，然后再创建妻子对象，丈夫对象关联妻子对象， 妻子对象关联丈夫对象，要求能够输出这个“丈夫对象”的妻子的名字，或者能够输出这个“妻子对象”的丈夫的名字。要求能够画出程序执行过程的内存图。 并且要求在程序中演示出空指针异常的效果。

11.  this 和 static （第十五天）

11.1.  static关键字

• static

1. static 翻译为“静态”
2. 所有 static 关键字修饰的都是类相关的，类级别的。
3. 所有 static修饰的，都是采用“类名.”的方式访问。
4. static 修饰的变量：静态变量  ， static修饰的方法：静态方法

• 变量的分类：变量根据声明的位置进行划分：

• 在方法体当中声明的变量叫做：局部变量。
• 在方法体外声明的变量叫做：成员变量。

• 成员变量又可以分为：实例变量、静态变量

• 实例相关的，必须先有对象，才能访问，可能会出现空指针异常。

// 成员变量中的实例变量

int i;

// 实例方法

public void m2(){

// 局部变量

int x = 20;

}

• 静态的，都是类相关的，访问时采用“类名.”的方式访问。不需要new对象。不需
  要对象的参与即可访问。没有空指针异常的发生。

  // 成员变量中的静态变量

  static int k;

// 静态方法

  public static void m1(){

  // 局部变量

  int m = 100;

}

11.1静态变量

1. 什么时候变量为静态变量

• 类特征（描述的状态是所有对象共有的特征，时为静态变量。）
• 当变量为实例变量：一个对象一份的是实例变量。

public class StaticTest02{

  public static void main(String[] args){

  Chinese c1 = new Chinese("1231456456456456","张三","中国");

  System.out.println(c1.idCard);

  System.out.println(c1.name);

  System.out.println(c1.country);

  Chinese c2 = new Chinese("7897897896748564","李四","中国");

      System.out.println(c2.idCard);

      System.out.println(c2.name);

      System.out.println(c2.country);

  }

}

// 定义一个类：中国人

class Chinese{

      // 身份证号

      // 每一个人的身份证号不同，所以身份证号应该是实例变量，

      一个对象一份。

      String idCard;

      // 姓名

      // 姓名也是一个人一个姓名，姓名也应该是实例变量。

      String name;

      // 国籍

      // 对于“中国人”这个类来说，国籍都是“中国”

      ，不会随着对象的改变而改变。

      // 显然国籍并不是对象级别的特征。

      // 国籍属于整个类的特征。整个族的特征。

      // 假设声明为实例变量，内存图是怎样的？

      // 假设声明为静态变量，内存图又是怎样的?

      String country;

      // 无参数

  public Chinese(){

}

// 有参数

  public Chinese(String s1,String s2, String s3){

  idCard = s1;

  name = s2;

  country = s3;

  }

}

*/

• 实例变量内存图的内存图

• 当变量为静态变量

• 静态变量的内存图

 

public class StaticTest02{

public static void main(String[] args){

// 访问中国人的国籍

// 静态变量应该使用类名.的方式访问

System.out.println(Chinese.country);

Chinese c1 = new Chinese("1231456456456456","张三");

System.out.println(c1.idCard);

System.out.println(c1.name);

Chinese c2 = new Chinese("7897897896748564","李四");

System.out.println(c2.idCard);

System.out.println(c2.name);

// idCard是实例变量，必须先new对象，通过“引用.

” 访问

// 错误: 无法从静态上下文中引用非静态 变量 idCard

//System.out.println(Chinese.idCard);

}

}

// 定义一个类：中国人

class Chinese{

// 身份证号

// 每一个人的身份证号不同，所以身份证号应该是实例变量，

一个对象一份。

String idCard;

// 姓名

// 姓名也是一个人一个姓名，姓名也应该是实例变量。

String name;

// 国籍

// 重点重点五颗星：加static的变量叫做静态变量

// 静态变量在类加载时初始化，不需要new对象，静态变量的空间就开出来了。

// 静态变量存储在方法区。

static String country =

"中国";

// 无参数

public Chinese(){

}

// 有参数

public Chinese(String s1,String s2){

idCard = s1;

name = s2;

}

}

2. Jvm 中的变量

• 栈：方法只要执行，会压栈。（局部变量）
• 堆：new出来的对象都在堆中。垃圾回收器主要针对。（实例变量）
• 方法区：类的信息，字节码信息，代码片段。（静态变量）

2. 变量的初始化：

• 静态变量：类加载时初始化。
• 实例变量：new运算符调用构造方法时完成初始化

11.1.2. 静态变量的空指针异常

• 静态变量不需要对象存在不会出现空指针异常
• 静态、实例的访问

• 实例的：一定需要使用“引用.”来访问。
• 静态的：
  建议使用“类名.”来访问，但使用“引用.”也行（不建议使用"引用."）。
  静态的如果使用“引用.”来访问会让程序员产生困惑：程序员以为是实例的呢。
• 结论：
  空指针异常只有在什么情况下才会发生呢?
  只有在“空引用”访问“实例”相关的，都会出现空指针异常。

• eg:

public class StaticTest03{

public static void main(String[] args){

// 通过"类名.

"的方式访问静态变量

System.out.println(Chinese.country);

// 创建对象

Chinese c1 = new Chinese("1111111"

,

"张三");

System.out.println(c1.idCard); // 1111111

System.out.println(c1.name); // 张三

System.out.println(c1.country); // 中国

// c1是空引用

c1 = null;

// 分析这里会不会出现空指针异常？

// 不会出现空指针异常。

// 因为静态变量不需要对象的存在。

// 实际上以下的代码在运行的时候，还是：

System.out.println(Chinese.country);

System.out.println(c1.country);

// 这个会出现空指针异常，因为name是实例变量。

//System.out.println(c1.name);

}

}

class Chinese{

// 实例变量

String idCard;

String name;

// 静态变量

static String country =

"中国";

//构造方法

public Chinese(String x, String y){

idCard = x;

name = y;

}

}

• 总结：从第一天开始讲解HelloWorld到目前为止，一个类当中一共就写过这些东西。

• 类{

• 实例相关的都是需要new对象的，通过"引用."访问。
  实例变量;
  实例方法;
• 静态相关的都是采用“类名.”访问。也可以使用“引用.”，只不过不建议。
  静态变量;
  静态方法;
  }

11.1.3. 静态方法、实例方法

1. 关于方法来说，什么时候定义为实例方法？什么时候定义为静态方法？

• 此方法一般都是描述了一个行为，如果说该行为必须由对象去触发。那么该方法定义为实例方法。
• 当这个方法体当中，直接访问了实例变量，这个方法一定是实例方法。

• 我们以后开发中，大部分情况下，如果是工具类的话，工具类当中的方法一般都是静态的。
  (静态方法有一个优点，是不需要new对象，直接采用类名调用，极其方便。工具类就是为了
  方便，所以工具类中的方法一般都是static的。)

• 什么是工具类？？？？？
  以后讲。（工具类就是为了方便编程而开发的一些类。）
  一个方法代表了一个动作。
  方法的代码片段放在方法区，但是方法执行过程当中需要的内存在栈中。

• 什么时候方法定义为实例方法？
  张三考试，得分90；
  李四考试，得分100
  不同的对象参加考试的结果不同，我们可以认定“考试”这个行为是与对象相关的行为。
  建议将“考试”这个方法定义为实例方法。

11.1.4. 静态代码快

1. 静态代码块语法是：
   static {
   java语句;
   java语句;
   }
   static静态代码块在类加载时执行，只执行一次，并且在main方法执行之前执行。
   静态代码块有啥作用？
   第一：静态代码块不是那么常用。（不是每一个类当中都要写的东西。）
   第二：静态代码块这种语法机制实际上是SUN公司给我们java程序员的一个特殊的时刻时机。
   这个时机叫做：类加载时机

2. 态代码快的执行顺序：

• 在类体中的静态方法没有先后执行顺序，到你了你在执行。
• 静态代码块一般是按照自上而下的顺序执行（谁在前先执行谁）。

3. 具体的业务

• 项目经理说了：大家注意了，所有我们编写的程序中，只要是类加载了，请记录一下类加载
  的日志信息（在哪年哪月哪日几时几分几秒，哪个类加载到JVM当中了）。
  思考：这些记录日志的代码写到哪里呢？
  写到静态代码块当中。

4. eg:

public class StaticTest06{

// 静态代码块（特殊的时机：类加载时机。）

static {

System.out.println("A");

}

// 一个类当中可以编写多个静态代码块

static {

System.out.println("B");

}

// 入口

public static void main(String[] args){

System.out.println("Hello World!");

}

// 编写一个静态代码块

static{

System.out.println("C");

}

}

/*

A

B

C

Hello World!

*/

11.1.5. 实例语句块（InstanceCode）

1. 实例语句块语法：
   {
   java语句；
   }
2. 实例语句块在什么时候执行？

• 只要是构造方法执行，必然在构造方法执行之前，自动执行“实例语句块”中的代码。
• 实际上这也是SUN公司为java程序员准备一个特殊的时机，叫做对象构建时机。

3. eg:

public class InstanceCode{

  //入口

public static void main(String[] args){

System.out.println("main begin");

new InstanceCode();

new InstanceCode();

new InstanceCode("abc");

new InstanceCode("xyz");

}

//实例语句块

{

System.out.println("实例语句块执行！");

}

// Constructor

public InstanceCode(){

System.out.println("无参数构造方法");

}

// Constructor

public InstanceCode(String name){

System.out.println("有参数的构造方法");

}

}

11.1.6. 代码顺序要求

1. 到目前为止，你遇到的所有java程序，有顺序要求的是哪些？
   第一：对于一个方法来说，方法体中的代码是有顺序的，遵循自上而下的顺序执行。
   第二：静态代码块1和静态代码块2是有先后顺序的。
   第三：静态代码块和静态变量是有先后顺序的,谁在前 先执行谁
   第四：方法与方法之间没有先后顺序

第五：执行顺序：

（1）父类静态对象和静态代码块

（2）子类静态对象和静态代码块

（3）父类非静态对象和非静态代码块

（4）父类构造函数

（5）子类非静态对象和静态代码块

（6）子类构造函数

其中：类中静态块按照声明顺序执行，并且（1）和（2）不需要调用 new 类实例的时候就执行了 （就是在类加载到方法区前就执行了 ）

Eg：

2. 总结到目前为止类可以出现的代码：
   类体{
   实例变量;
   实例方法;
   静态变量;

静态方法;
构造方法;
静态代码块; 实例语句块;
方法(){
// 局部变量
int i = 100;
}
}

3. 判读以下程序的代码执行顺序

//判断以下程序的执行顺序

public class CodeOrder{

// 静态代码块

static{

System.out.println("A");

}

// 入口

// A X Y C B Z

public static void main(String[] args){

System.out.println("Y");

new CodeOrder();

System.out.println("Z");

}

// 构造方法

public CodeOrder(){

System.out.println("B");

}

// 实例语句块

{

System.out.println("C");

}

// 静态代码块

static {

System.out.println("X");

}

}

11.2.  this关键字

11.2.1. this

1. this是一个关键字，全部小写。
2. this是什么，在内存方面是怎样的？ 一个对象一个this。

• 一个对象一个this。
• this是一个变量，是一个引用。
• this保存当前对象的内存地址，指向自身。 所以，严格意义上来说，this代表的就是“当前对
  象” this存储在堆内存当中对象的内部

3.  this只能使用在实例方法中。谁调用这个实例方法，this就是谁。

所以this代表的是：当前对象。

4. “this.”大部分情况下是可以省略的。
5. 为什么this不能使用在静态方法中？
   this代表当前对象，静态方法中不存在当前对象。
6. eg:

public class ThisTest01{

public static void main(String[] args){

Customer c1 = new Customer("张三");

c1.shopping();

Customer c2 = new Customer("李四");

c2.shopping();

Customer.doSome();

}

}

// 顾客类

class Customer{

// 属性

// 实例变量（必须采用“引用.

”的方式访问）

String name;

//构造方法

public Customer(){

}

public Customer(String s){

name = s;

}

// 顾客购物的方法

// 实例方法

public void shopping(){

// 这里的this是谁？this是当前对象。

// c1调用shopping(),this是c1

// c2调用shopping(),this是c2

//System.out.println(this.name + "正在购物!");

// this. 是可以省略的。

// this. 省略的话，还是默认访问“当前对象”的name。

System.out.println(name + "正在购物!");

}

// 静态方法

  public static void doSome(){

// this代表的是当前对象，而静态方法的调用不需要对象。矛盾了。

// 错误: 无法从静态上下文中引用非静态 变量 this

//System.out.println(this);

}

}

class Student{

// 实例变量，怎么访问？必须先new对象，通过“引用.

”来访问。

String name =

"zhangsan";

// 静态方法

public static void m1(){

//System.out.println(name);

// this代表的是当前对象。

//System.out.println(this.name);

// 除非你这样

Student s = new Student();

System.out.println(s.name);

}

//为什么set和get方法是实例方法？

public static void setName(String s){

name = s;

}

public String getName(){

return name;

}

11.3.  this在jvm中的内存图

11.4. 重新认识作用域

• 在大多数情况下，出了大括号就不认识了
• 下面的这个int i 虽然在同一个作用域，但是它是实例变量访问需要创建对象，通过 “引用.” 的方式访问。
• 分析：i变量在main方法中能不能访问？？？？

public class ThisTest02{

// 实例变量

int i = 100; // 这个i变量是不是必须先new对象才能访问。

// 静态变量

static int k = 111;

// 静态方法

public static void main(String[] args){

// 错误: 无法从静态上下文中引用非静态 变量 i

// System.out.println(i);

// 怎么样访问i

ThisTest02 tt = new ThisTest02();

System.out.println(tt.i);

// 静态变量用“类名.

”访问。

System.out.println(ThisTest02.k);

// 类名. 能不能省略？

// 可以

System.out.println(k);

}

}

11.5.  day15天作业

• 题目：
  一、请通过代码封装，实现如下需求： 编写一个类Book，代表教材:
  1.  具有属性：名称（title）、页数（pageNum）
  2.  其中页数不能少于200页，否则输出错误信息，并赋予默认值200
  3.  为各属性提供赋值和取值方法
  4. 具有方法:detail，用来在控制台输出每本教材的名称和页数
  5. 编写测试类BookTest进行测试：为Book对象的属性赋予初始值，并调用Book对象的detail方  法，看看输出是否正确

二、写一个名为Account的类模拟账户。该类的属性和方法如下所示。

该类包括的属性：账户id，余额balance，年利率annualInterestRate；

包含的方法：各属性的set和get方法。取款方法withdraw()，存款方法deposit()

写一个测试程序

（1） 创建一个Customer，名字叫Jane Smith，他有一个账号为1000，余额为2000，年利率为1.23%的账 户

（2） 对Jane Smith操作：

存入100元，再取出960元，再取出2000。打印Jane Smith的基本信息

信息如下显示：

成功存入：100 成功取出：960

余额不足，取钱失败

Customer [Smith，Jane] has a account ：id is 1000 annualInterestRate is 1.23% balance is

1140.0

三、(封装)已知一个类 Student 代码如下：

class Student{ String name; int age;

String address; String zipCode; String mobile;

}

要求：

1、把Student 的属性都作为私有，并提供get/set 方法以及适当的构造方法。

2、为Student 类添加一个getPostAddress 方法，要求返回Student 对象的地址和邮编。

11.6.  this不能省略

• this可以使用在实例方法中，不能使用在静态方法中。
• this关键字大部分情况下可以省略，什么时候不能省略呢？
  在实例方法中，或者构造方法中，为了区分局部变量和实例变量，这种情况下：this. 是不能省略
  的。
• this. 的作用是：区分局部变量和实例变量。

// 学生类

class Student{

//学号

private int no;

//姓名

private String name;

//构造方法无参

public Student(){

}

// 分析一下：以下代码哪里写的不好。

//可读性差

//构造方法有参

/*

public Student(int i, String s){

no = i;

name = s;

}

*/

// 上面的构造方法也增强以下可读性

public Student(int no, String name){

this.no = no;

this.name = name;

}

/*

public void setNo(int no){ // 就近原则。

no = no; //这两个no都是局部变量no，和实例变量no没关系。

}

*/

public void setNo(int no){

//no是局部变量

//this.no 是指的实例变量。

this.no = no; // this. 的作用是：区分局部变量和实例变量。

}

*/

public String getName(){ // getName实际上获取的是“当前对象”的名字。

//return this.name; // 严格来说，这里是有一个 this. 的。只不过这个 this.

是可以省略的。

return name;

}

}

11.7.  this出现在构造方法中

1. this除了可以使用在实例方法中，还可以用在构造方法中。

• 通过当前的构造方法1去调用另一个本类的构造方法2，可以使用以下语法格式：this(实际参
  数列表);
• “构造方法1”和“构造方法2” 都是在同一个类当中。
• this() 这个语法作用：代码复用。
• 死记硬背：对于this()的调用只能出现在构造方法的第一行

eg:

class Date{ // 以后写代码都要封装，属性私有化，对外提供setter and getter

//年

private int year;

//月

private int month;

//日

private int day;

// 构造方法无参

// 调用无参数构造方法，初始化的日期是固定值。

public Date(){

//错误: 对this的调用必须是构造器中的第一个语句

//System.out.println(11);

/*

this.year = 1970;

this.month = 1;

this.day = 1;

*/

this(1970, 1, 1);

}

// 构造方法有参数

public Date(int year, int month, int day){

this.year = year;

this.month = month;

this.day = day;

}

11.8.  this总结

• this 是一个关键字，是一个引用，保存内存地址，指向自身。
• this 可以使用在实例方法中，也可以使用在构造方法中。
• this出现在实例方法中其实代表的是当前对象。
• this不能使用在静态方法中。
• this. 大部分情况下可以省略，但是用来区分局部变量和实例变量的时候不能省略。
• this() 这种语法只能出现在构造方法第一行，表示当前构造方法调用本类其他的构造方法，目的是代码复用

11.9.  面向对象编程思想的培养

• 先分析 有哪几类对象
• 然后 找到类与类之间的关联
• 不同的类应该放在不同文件

11.10.  day 16作业

1. 题目：

• 1、猜数字游戏
  一个类A有一个实例变量v，从键盘接收一个正整数作为实例变量v的初始值。另外再定义一个类B，对A类的实例变量v进行猜测。
  如果大了则提示大了小了则提示小了
  等于则提示猜测成功
• 2、请定义一个交通工具(Vehicle)的类其中有属性：
  速 度 (speed) 体积(size)等等
  方法移动(move())
  设置速度(setSpeed(int speed))
  加速speedUp(),
  减速speedDown()等等.
  最后在测试类Vehicle中的main()中实例化一个交通工具对象并通过方法给它初始化speed,size的值并且打印出来。

 另外调用加速减速的方法对速度进行改变。

• 3、在程序中经常要对时间进行操作但是并没有时间类型的数据。
  那么我们可以自己实现一个时间类来满足程序中的需要。
  定义名为MyTime的类其中应有三个整型成员时hour分minute秒second
  为了保证数据的安全性这三个成员变量应声明为私有。
  为MyTime类定义构造方法以方便创建对象时初始化成员变量。
  再定义diaplay方法用于将时间信息打印出来。
  为MyTime类添加以下方法
  addSecond(int sec)
  addMinute(int min)
  addHour(int hou)
  subSecond(int sec)
  subMinute(int min)
  subHour(int hou)
  分别对时、分、秒进行加减运算。
• 4、编写Java程序模拟简单的计算器。
  定义名为Number的类其中有两个整型数据成员n1和n2应声明为私有。
  编写构造方法赋予n1和n2初始值
  再为该类定义加addition()、减subtration()、乘multiplication()、除division()等公有实例方法
  分别对两个成员变量执行加、减、乘、除的运算。
  在main方法中创建Number类的对象调用各个方法并显示计算结果

5、编写Java程序用于显示人的姓名和年龄。

定义一个人类Person该类中应该有两个私有属性姓名name和年龄age。
定义构造方法用来初始化数据成员。再定义显示display方法将姓名和年龄打印出来。
在main方法中创建人类的实例然后将信息显示

12.  继承（第十六天）

12.1.  复习变量的访问

• 类加载机制中，是这样的：在程序执行之前，凡是需要加载的类全部加载到JVM当中。
• 先完成加载才会执行main方法。
• 私有的是可以在本类中访问的。在其它类中必须使用set和get方法。
• 程序再怎么变化，万变不离其宗，有一个固定的规律：

• 所有的实例相关的都是先创建对象，通过“引用.”来访问。
• 所有的静态相关的都是直接采用“类名.”来访问。

• 大结论：
  只要负责调用的方法a和被调用的方法b在同一个类当中：this. 可以省略、类名. 可以省略