封装（第14天）

10.1. 封装的特性

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

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

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

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

// 这是没有封装的Person。

public class Person{

// 实例变量(属性)

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

}

10.2. 封装的步骤

怎么进行封装：

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

代码说明：

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

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 关键字

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

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

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

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

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

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

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

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

int i;

// 实例方法

public void m2(){

// 局部变量

int x = 20;

}

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

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

static int k;

// 静态方法

public static void m1(){

// 局部变量

int m = 100;

}

11.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;

}

Jvm 中的变量

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

变量的初始化：

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

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

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

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

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. 静态方法、实例方法

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

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

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

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

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

11.1.4. 静态代码快

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

态代码快的执行顺序：

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

具体的业务

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

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

}

Hello World!

11.1.5. 实例语句块（InstanceCode）

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

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

public class InstanceCode{

//入口

public static void main(String[] args){

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

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. 代码顺序要求

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

第五：执行顺序：

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

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

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

（4）父类构造函数

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

（6）子类构造函数

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

Eg：

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

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

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

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

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

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

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

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

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

“this.”大部分情况下是可以省略的。
为什么this不能使用在静态方法中？
this代表当前对象，静态方法中不存在当前对象。
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出现在构造方法中

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、猜数字游戏
一个类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. 可以省略、类名. 可以省略

Java基础部分详解（三）--->封装

封装（第14天）

10.1. 封装的特性

10.2. 封装的步骤

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

10.4. 封装步骤总结

10.5. 初步了解 static 关键字

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

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

10.8. 第十四天作业

11. this 和 static （第十五天）

11.1. static关键字

11.1静态变量

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

11.1.3. 静态方法、实例方法

11.1.4. 静态代码快

11.1.5. 实例语句块（InstanceCode）

11.1.6. 代码顺序要求

11.2. this关键字

11.2.1. this

11.3. this在jvm中的内存图

11.4. 重新认识作用域

11.5. day15天作业

11.6. this不能省略

11.7. this出现在构造方法中

11.8. this总结

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

11.10. day 16作业

12. 继承（第十六天）

12.1. 复习变量的访问

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java基础部分详解（三）--->封装

封装 （第14天）

10.1. 封装的特性

10.2. 封装的步骤

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

10.4. 封装步骤总结

10.5. 初步了解 static 关键字

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

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

10.8. 第十四天作业

11. this 和 static （第十五天）

11.1. static关键字

11.1静态变量

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

11.1.3. 静态方法、实例方法

11.1.4. 静态代码快

11.1.5. 实例语句块（InstanceCode）

11.1.6. 代码顺序要求

11.2. this关键字

11.2.1. this

11.3. this在jvm中的内存图

11.4. 重新认识作用域

11.5. day15天作业

11.6. this不能省略

11.7. this出现在构造方法中

11.8. this总结

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

11.10. day 16作业

12. 继承（第十六天）

12.1. 复习变量的访问

热门文章

最新文章

相关课程

相关电子书

相关实验场景

封装（第14天）