第二章 -- 面向对象基础知识

Day01

1丶成员变量和局部变量的区别

(1)在类中的位置不同

成员变量：类中方法外

局部变量：方法定义中或者方法声明上

(2)在内存中的位置不同

成员变量：在堆中

局部变量：在栈中

(3)生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

(4)初始化值不同

成员变量：有默认值

局部变量：没有默认值，必须定义，赋值，然后才能使用

 

--------------------------------------------------------------------------------

 

注意: 栈中的变量需要我们初始化的, 而堆中的内存不用我们初始化,默认有JVM(中的加载器加载时)初始化的

 

2丶Student s = new Student();都做了什么???

(1)把Student.class文件加载到内存

(2)在栈内存为s开辟空间

(3)在堆内存为学生对象申请空间

(4)给学生的成员变量进行默认初始化。null,0

(5)给学生的成员变量进行显示初始化。林青霞,27

(6)通过构造方法给成员变量进行初始化。刘意,30

(7)对象构造完毕，把地址赋值给s变量

 

3丶面向对象的static加载过程

 

  ● 最右边的静态区也被称之为静态上下文

 

4丶static 使用的注意事项

--------------------------------------------------------------------------------

// static 关键字注意事项

// (1) 静态方法中没有this关键字

// 静态是随着类的加载而加载的, this指针是随着对象的创建的创建而产生的

// 静态比对象要早的被JVM 加载

// (2) 静态方法只能访问静态的成员变量和静态的方法

//这里对象对成员函数的调用时可以访问静态的方法和属性的

//但是静态的方法无法访问非静态的属性和非静态的方法

// 总结: 上面的问题的出现本质的原因是因为类加载器的加载时机问题导致的

// 静态的方法或者静态的属性在类加载器加载类的时候便存在了, 它被存放在 .class中

// 在解释器解释 .class 字节码文件的时候便将静态的方法和静态的属性和非静态的

//方法和非静态的变量的声明已经被加载到内存中, 此时对象还未存在

//当解释器读取到类似 Person p = new Person() 的时候将会去申请内存, 此时

// 该类的对象才在内存中被申请出来, 此时静态的方法便存在了, 所以对象就可以调用

//以存在的静态的变量和静态的方法

    @Test

    public void test1()

    {

        Teacher t = new Teacher();

        t.show();

    }

}

 

class Teacher

{

    public int num = 10;

    public static int num2 = 20;

    

    public void show()

    {

        System.out.println(num);

        System.out.println(this.num);

        System.out.println(Teacher.num2);

        function();

        function2();

    }

    

    public static void method()

    {

        // 无法从静态上下文引用非静态的变量 num

//      System.out.println(num);

        System.out.println(num2);

        // 无法从静态上下文引用非静态的函数 function()

//      function();

        function2();

    }

    

    public void function()

    {

        

    }

    

    public static void function2()

    {

        

    }

--------------------------------------------------------------------------------

5丶静态变量和成员变量的不同

 

总结:

--------------------------------------------------------------------------------

5丶类作为形式参数的问题?(理解)

(1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

 

6:匿名对象(理解)

(1)没有名字的对象

(2)应用场景

A:调用方法，仅仅只调用一次的时候。

b:可以作为实际参数传递。

7:封装(理解)

(1)隐藏实现细节，提供公共的访问方式

(2)好处：

A:隐藏实现细节，提供公共的访问方式

B:提高代码的复用性

C:提高代码的安全性

(3)设计原则

把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式

(4)private是封装的一种体现。

封装：类，方法，private修饰成员变量

 

8:private关键字(掌握)

(1)私有的意义，可以修饰成员变量和成员方法

(2)特点：

被private修饰的后的成员只能在本类中被访问

(3)private的应用：

以后再写一个类的时候：

把所有的成员变量给private了

提供对应的getXxx()/setXxx()方法

 

9:this关键字(掌握)

(1)代表当前类的引用对象

记住：哪个对象调用方法，该方法内部的this就代表那个对象

(2)this的应用场景：

A:解决了局部变量隐藏成员变量的问题

B:其实this还有其他的应用，明天讲解。

 

10:构造方法(掌握)

(1)作用：用于对对象的数据进行初始化

(2)格式：

A:方法名和类名相同

B:没有返回值类型，连void都不能有

C:没有返回值

思考题：构造方法中可不可以有return语句呢?

可以。而是我们写成这个样子就OK了：return;

其实，在任何的void类型的方法的最后你都可以写上：return;

(3)构造方法的注意事项

A:如果我们没写构造方法，系统将提供一个默认的无参构造方法

B:如果我们给出了构造方法，系统将不再提供默认构造方法

如果这个时候，我们要使用无参构造方法，就必须自己给出。

推荐：永远手动自己给出无参构造方法。

(4)给成员变量赋值的方式

A:setXxx()

B:带参构造方法

(5)标准案例

class Student {

    private String name;

    private int age;

    

    public Student(){}

    

    public Student(String name,int age) {

        this.name = name;

        this.age = age;

    }

    

    public String getName() {

        return name;

    }

    

    public void setName(String name) {

        this.name = name;

    }

    

    public int getAge() {

        return age;

    }

    

    public void setAge(int age) {

        this.age = age;

    }

}

        

测试：

class StudentDemo {

    public static void main(String[] args) {

        //方式1

        Student s1 = new Student();

        s1.setName("林青霞");

        s1.setAge(27);

        System.out.println(s1.getName()+"---"+s1.getAge());

        

        //方式2

        Student s2 = new Student("刘意",30);

        System.out.println(s2.getName()+"---"+s2.getAge());

    }

}

 

11:面向对象的练习题(掌握)

(1)标准的手机类的定义和测试

(2)Demo类有求和方法，Test类进行测试。

什么时候定义成员变量?

当该变量是用来描述一个类的时候。

(3)长方形案例

(4)员工案例

(5)MyMath案例(自己提供加减乘除并测试)

13:static关键字(理解)

(1)静态的意思。可以修饰成员变量和成员方法。

(2)静态的特点：

A:随着类的加载而加载

B:优先与对象存在

C:被类的所有对象共享

这其实也是我们判断该不该使用静态的依据。

举例：饮水机和水杯的问题思考

D:可以通过类名调用

既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

(3)静态的内存图

静态的内容在方法区的静态区

(4)静态的注意事项；

A:在静态方法中没有this对象

B:静态只能访问静态(代码测试过)

(5)静态变量和成员变量的区别

A:所属不同

静态变量：属于类，类变量

成员变量：属于对象，对象变量，实例变量

B:内存位置不同

静态变量：方法区的静态区

成员变量：堆内存

C:生命周期不同

静态变量：静态变量是随着类的加载而加载，随着类的消失而消失

成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失

D:调用不同

静态变量：可以通过对象名调用，也可以通过类名调用

成员变量：只能通过对象名调用

(6)main方法是静态的

public:权限最大

static:不用创建对象调用

void:返回值给jvm没有意义

main:就是一个常见的名称。

String[] args:可以接收数据，提供程序的灵活性

格式：java MainDemo hello world java

  java MainDemo 10 20 30

--------------------------------------------------------------------------------

课后作业

--------------------------------------------------------------------------------

14:局部变量和成员变量的区别?

(1)类的位置不同,

 一个类内, 一个类外

(2)在内存的位置不同, 

一个栈区一个堆区

(3)生命周期不同, 

一个在函数执行完毕后销毁, 一个在没被引用后由 GC 自动销毁

(4)初始化值得不同

成员变量有默认初始化, 局部变量需要手动初始化

15:形式参数分别为基本类型和引用类型的问题?

基本类型: 由 8 大数据结构组成的, 

引用类型: 由 new 或者其他复杂数据类型的对象作为参数

16:匿名对象是什么?应用场景是什么?

匿名对象时没有名字的一个对象, 在堆中分配了内存, 应用场景主要是作为参数传递, 节省设计程序的时间

17:封装是什么?java中封装的体现有哪些?请举例说明。

封装:它以类作为单位, 对类中的属性和方法做权限, 隐藏该隐藏的数据(隐藏实现过程), 公开该公开的数据和方法(公开公共方法), 隐藏实现细节, 公开共有访问

18:this关键字是什么?this关键字的应用场景?

this 关键字是一个对象在堆中的首地址符号, 是一个对象的地址, 

this的应用场景: 是在使用 set 和 get 的时候或者在类中存在局部变量和成员变量同名时使用的

19:构造方法的作用是什么?构造方法的特点是什么?构造方法的注意事项是什么?构造方法中可不可以写return语句呢?

构造方法的作用: 

用于初始化一个对象, 为对象内部的成员变量初始化值, 分配this指针的地址, 

构造函数的特点: 

与类的名字相同, 不存在返回值, 在对象new 的时候自动调用, 其他时候除非子类使用super 否则无法调用

构造方法的注意事项: 

如果没有显示的写出构造函数的话 JVM 会为他生产一个默认的无参构造函数, 

只要显示的给出了构造函数的话, 系统不会再次提供构造函数

构造函数重载体现在参数的不同

构造函数的重载是构造函数的, 方法的重载是方法的, 两者不能混为一谈

20:给成员变量赋值有几种方式?

使用this指针指向成员变量

写一个set 函数去设置成员变量

当不存在同名变量时, 可以直接使用成员变量名直接赋值

21:标准的代码编写及测试：

A:学生类的案例

B:手机类的案例

C:长方形类的案例

22:static关键字是什么?有什么特点?什么时候用呢?

static 关键字是个修饰符

static 用于修饰变量和函数的, 被其修饰的变量和函数将成为这个类特有的函数和变量, 为这个类申请的对象的共有属性

static 修饰的东西, 在类加载器加载的时候便被初始化和存储了, 他比对象要早出来

23:main方法各种修饰符及参数的解释?

main 方法是 static 静态函数

main方法的返回值是 void

main 方法是由 JVM 调用的

main 方法是程序运行的入口函数

main 函数的参数是 String [] 数组, 用于在控制台传入字符参数

--------------------------------------------------------------------------------

 

 

课后作业

--------------------------------------------------------------------------------

1:函数的概念?函数的格式?格式的解释说明

 

2:函数的调用

A:明确返回值类型的函数调用

B:void类型的函数调用

3:函数的练习：

A:求两个数据之和

B:判断两个数据是否相等

C:获取两个数中较大的值

D:打印m行n列的星形矩形

E:打印nn乘法表

 

4:什么是函数重载?以及函数重载的练习?把讲过的案例练习一次即可

函数的重载: 函数名相同, 函数的参数列表不同, 函数的返回值不做函数重载的条件

 

5:数组的概念?有什么特点?

数组: 用于存储多个相同数据类型变量的容器,

特点: 变量的类型是同一个数据类型

数组元素在内存中是连续的

 

6:一维数组的定义格式?

int [] arr = new int[10];

int arr[] = new int[10];

int arr[] = {1, 2, 4, 5, 6};

 

7:数组操作的两个小问题

 

8:数组常见操作:

数组遍历(依次输出数组中的每一个元素)

数组获取最值(获取数组中的最大值最小值)

数组元素逆序 (就是把元素对调)

数组查表法(根据键盘录入索引,查找对应星期)

数组元素查找(查找指定元素第一次在数组中出现的索引)

 

1:二维数组定义格式?

  看懂针对每种格式的内存图解?

定义格式;

int[][] arr = new int[x][y];

int[][] arr = new int[x][];

int arr[][] = {{d, d, d}, {y, y, y, y}, {x, x, x}};

--------------------------------------------------------------------------------

Day02

一丶代码块

(1) 局部代码块

节省系统资源

(2) 构造代码块

1) 调用时机比构造函数块

2) 将每个对象创建时(调用构造函数)都会执行的代码放入构造代码块中

3) 对对象进行初始化的

(3) 静态代码块

1) 只加载一次

2) 静态代码块 快于 构造代码块

3) 一般对类进行初始化

(4) 同步代码块 --- 线程同步时说

 

(5) 面试题1

静态代码块, 构造代码块, 构造方法的执行顺序?

答: 静态代码块最先, 之后是构造代码块, 最后是构造方法, 静态代码块只执行一次, 构造代码块每次调用构造方法都执行

例子:

--------------------------------------------------------------------------------

package com.bangiao.代码块的执行顺序03;

 

import org.junit.Test;

 

class Student

{

    static {

        System.out.println("静态代码块");

    }

    {

        System.out.println("构造代码块");

    }

    public Student()

    {

        super();

        // TODO Auto-generated constructor stub

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

    }

    

}

 

public class _Main

{

    static {

        System.out.println("_Main的静态代码块");

    }

    @Test

    public void test1()

    {

        System.out.println("我是测试方法");

        Student s1 = new Student();

        Student s2 = new Student();

    }

}

 

Out :

_Main的静态代码块

我是测试方法

静态代码块

构造代码块

构造方法

--------------------------------------------------------------------------------

总结:

类加载器是否加载某个类, 通过用户是否使用了, 我们的这个类, 如果使用了, 我们才去加载, 如果没使用, 就不加载, 在说一句, 你觉得类加载器会很傻很天真的把你所有写的类都加载掉???那得多慢, 而且很多类在没使用的时候你也加载???

Day03

1:二维数组定义格式?

(1) int[][] arr = new int[10][10];

(2) int [][]arr = new int[10][];

(3) int arr[][] = new int[10][10];

  看懂针对每种格式的内存图解?

 

2:案例

A:二维数组遍历

B:公司年销售额求和

某公司按照季度和月份统计的数据如下：单位(万元)

第一季度：22,66,44

第二季度：77,33,88

第三季度：25,45,65

第四季度：11,66,99

C:打印杨辉三角形(行数可以键盘录入)

 

3:两个思考题

A:参数传递问题

B:数据加密问题

4:回顾前5天知识，准备考试。

准备纸张和笔。

如果要用多张纸，要求每张纸张都写上自己的名字。

字迹要清晰明了，否则直接扣分1分。

5:面向对象思想概述和举例

6:类与对象分别是什么，举例说明

类是一个模版, 是创建对象的数据结构, 其中类存放了很多方法 ,但类不存在实体, 需要实例化为对象

7:如何定义一个类,类的组成

class  Person

{

属性

方法

}

8:如何使用一个类的成员

.

9:模仿学生类和手机类写一个人类,并测试。

Day04

1:局部变量和成员变量的区别?

A:在类中位置不同

B:在内存中位置不同

C:生命周期不同

D:初始化值不同

2:形式参数分别为基本类型和引用类型的问题?

形式参数：基本类型 形参的改变不影响实际参数

形式参数：引用类型 形参的改变直接影响实际参数

如果一个方法的形式参数是一个类的名称，那么这里需要的是该类的对象。

 

3:匿名对象是什么?应用场景是什么?

没有名字的对象。

应用场景：

A:调用方法，仅仅调用一次的时候

B:作为实际参数传递

 

4:封装是什么?java中封装的体现有哪些?请举例说明。

封装：隐藏实现细节，提供公共的访问方式。

 

封装的体现：

类，方法，private修饰成员变量

 

5:this关键字是什么?this关键字的应用场景?

this:代表当前类的对象应用

 

应用场景：解决局部变量隐藏成员变量的问题

 

6:构造方法的作用是什么?构造方法的特点是什么?

构造方法的注意事项是什么?构造方法中可不可以写return语句呢?

 

作用：用于对对象的数据进行初始化

 

特点：

A:方法名和类名相同

B:没有返回值类型，连void都不能有

C:没有返回值

注意事项：

A:如果我们不给构造方法，系统就提供一个默认的无参构造方法

B:如果我们给出了构造方法，系统就不再提供默认构造方法

这个时候我们想用，就要自己提供。建议自己提供无参构造方法。

class Student {

    private String name;

    

    public Student(){}

    

    //getXxx/setXxx

}

构造方法可以有return语句，但是不能有明确的返回值。也就是说return;

 

7:给成员变量赋值有几种方式?

A:setXxx()

B:带参构造方法

 

8:标准的代码编写及测试：

A:学生类的案例

B:手机类的案例

C:长方形类的案例

class Student {

    private String name;

    private int age;

    

    public Student(){}

    

    public String getName() {

        return name;

    }

    

    public void setName(String name) {

        this.name = name;

    }

    

    public int getAge() {

        return age;

    }

    

    public void setAge(int age) {

        this.age = age;

    }

}

    

class StudentDemo {

    public static void main(String[] args) {

        Student s = new Student();

        s.setName("林青霞");

        s.setAge(27);

        System.out.println(s.getName()+"---"+s.getAge());

    }

}

 

9:一个类的成员变量初始化过程

Student s = new Student();

A:把Student.class文件加载到内存(类加载器)

B:在栈内存为s开辟空间

C:在堆内存为学生对象申请空间

D:给学生对象的成员变量进行默认初始化

E:给学生对象的成员变量进行显示初始化

F:通过构造方法给学生对象的成员变量进行初始化

G:把堆内存的地址赋值给s变量

10:static关键字是什么?有什么特点?什么时候用呢?

static静态的意思，可以修饰成员变量和成员方法。

特点：

A:随着类的加载而加载

B:优先与对象存在

C:被所有对象共享

D:可以通过类名调用

什么时候用?

A:当一个成员被所有对象共享的时候。

B:工具类的时候。

11:静态变量和成员变量的区别

A:所属不同

B:内存位置不同

C:生命周期不同

D:调用不同

12:main方法各种修饰符及参数的解释?

public:权限修饰符，权限最大

static:可以不用创建对象

void:返回值给jvm无意义

main:一个方法名，大家都默认的

String[] args:接收键盘录入对象