对象（类和对象的理解）及对象的理解和使用

实例化：

java程序员是转换桥梁

1 面向过程（以我为中心）和面向对象有什么区别？

从语言方面触发：

对于c语言来说，是完全面向过程的。

对于c++语言来说，是一半面向过程，一半是面向过程的。

对于java来说，是完全面向对象的。

什么是面向过程的开发方式？

面向过程的开发方式主要的特点是：

注重步骤，注重的是实现这个功能的步骤。

第一步干什么

第二步干什么

...

另外面向过程也注重实现功能的因果关系。

因为A所以B

因为B所以C

因为C所以D

...

面向过程中没有对象的概念。只是实现这个功能的步骤以及因果关系。

面向过程有什么缺点（耦合度高扩展性差）？

面向过程最主要是每一步与每一步的因果关系，其中A步骤因果关系到B步骤

A和B联合起来形成一个子模块，子模块和子模块之间又因为因果关系结合在一起，假设其中任何一个因果关系出现问题（错误），

此时整个系统的运转都会出问题。（代码和代码之间的耦合度太高，扩展力太差。）

螺栓螺母拧在一起：耦合度高吗？

这是耦合度低的，因为螺栓螺母可以再拧开。（他们之间是有接口的）

螺栓螺母拧在一起之后，再用焊条焊接在一起，耦合度高吗？

这个耦合度就很高了。耦合度就是黏连程度。

往往耦合度高的扩展力就差。

耦合度高导致扩展力差。（集成显卡：计算机集成显卡不是独立的，是集成到主板上的。）

耦合度低导致扩展力强。（灯泡和灯口关系，螺栓螺母关系。）

采用面向过程的方式开发一台计算机是怎么样？

这台计算机将没有任何一个部件，所有的都是融合在一起。

你的这台计算机是一个实心的，没有部件的。

假设这台计算机的任何一个“部位”出问题，整个计算机就不能用了，必须扔掉了。（没有对象的概念）

采用面向对象的方式开发一台计算机是怎么样？

内存条是一个对象。

主板是一个对象。

CPU是一个对象。

硬盘是一个对象。

然后这些对象组装在一起，形成一台计算机。

假设其中CPU坏了，我们可以将CPU拆下来，换一个新的。

面向过程有什么优点？（快速开发）

对于小型功能，采用面向过程的方式开发，效率较高。

不需要前期进行对象的提取，模型的建立，采用面向过程方式可以直接开始干活。一上来直接写代码，编写因果关系。从而实现功能。

什么是面向对象的开发方式？

采用面向对对象的方式进行开发，更符合人类的思维方式。（面向对象成为主流的原因）

人类就是以“对象”的方式去认识世界的。

所以面向对象更容易让我们接受。

面向对象就是将现实世界分割成不同的单元，然后每一个单元都实现成对象，然后给一个环境驱动以下，让各个对象之间协作起来形成一个系统。

对象“张三”

对象“香烟”

对象“打火机”

对象“吸烟的场所”

然后将以上的4个对象组合在一起，就可以模拟一个人的抽烟场景。

其中“张三”对象可以更换为“李四”

其中“香烟”也可以更换品牌

其中“打火机”也可以更换

其中“吸烟的场所”也可以更换

采用面向对象的方式进行开发：

耦合度低，扩展力强。

找一个合适的案例。说明一下面向对象和面向过程的区别？

蛋炒饭：鸡蛋和米饭完全混合在一起，没有独立对象的概念。

假设客户提出新需求：我只想吃蛋炒饭中的米饭，怎么办？

客户提出需求，软件开发者必须满足这个新需求，于是开始扩展。这个软件的扩展就是一场噩梦。（很难扩展，耦合度太高了。）

盖饭：

老板，来一份：鱼香肉丝盖饭

鱼香肉丝是一道菜，可以看成一个独立的对象。

米饭可以看成一个独立的对象。

两个对象准备好之后，只要一个动作，叫做：“盖”

这样两个对象就组合在一起了。

假设客户提出新需求，我不想吃鱼香肉丝盖饭，想吃西红柿鸡蛋盖饭。

这个扩展就很轻松了。直接把“鱼香肉丝”对象换成“西红柿鸡蛋”对象。

目前先听一下，需要三四年的时间才能彻底领悟面向对象。

面相过程主要关注的是：实现步骤以及整个过程。

面向对象主要关注的是：对象A、对象B、对象C，然后对象ABC组合，或者CBA组合......

2 OOA OOD OOP

当我们采用面向对象的方式贯穿整个系统的话，设计到三个术语：

OOA：面向对象分析（Object-Oriented Analysis）

OOD：面向对象设计（Object-Oriented Design）

OOP：面向对象编程（Object-Oriented Programming）

整个软件开发的过程，都是用OO进行贯穿的。

实现一个软件的过程：

分析（A） --> 设计（D） --> 编程（P）

在软件公司当中，一般同事与同事之间聊天，有的时候会突然说出来一个英语单词。

这种情况是很常见的。所以一些术语还是要知道的，不然会闹出笑话。

leader 领导/经理/组长

team 团队

PM 项目经理（整个项目的监管人）Project Manager

3 面向对象的三大特征

封装

继承

多态

任何一个面相对象的变成语言都包括这三个特征

例如：

python也有封装继承多态。

java也有封装继承多态

注意：java只是面向对象编程语言的一种

除了java之外，还有其他很多的编程语言也是面向对象的。

以上三个特征的名字先背会，后面一个一个进行学习。

4 类和对象的概念

面向对象当中最主要“一词”是：对象

什么是类？

类实际上在现实世界当中是不存在的，是一个抽象的概念。

是一个模板。是我们人类大脑进行思考、总结、抽象的一个结果。（主要是因为人类的大脑不一般才有了类的概念。）

类本质上是显示世界当中某些事物具有共同特征，将这些共同特征提取出来形成的概念就是一个“类”，“类”就是一个模板。

明星是一个类

什么是对象？

对象是实际存在的个体。（真实存在的个体）

宋小宝就是一个对象

姚明就是一个对象

刘德华就是一个对象

...

宋小宝、姚明、刘德华这三个对象都属于“明星”这个类。

在java语言中，要想得到“对象”，必须先定义“类”，对象是通过类这个模板创造出来的。

类就是一个模板：类中描述的是所有对象的“共同特征信息”

对象就是通过类创建出的个体。

这几个术语你需要自己能够阐述出来：

类：不存在的，人类大脑思考总结一个模板（这个模板当中描述了共同特征）

对象：实际存在的个体

实例：对象还有另一个名字叫做实例

实例化：通过类这个模板创建对象的过程，叫做：实例化

抽象：多个对象具有共同特征，进行思考总结抽取共同特征的过程。

类 -----> 【实例化】 ------> 对象（实例）

对象 -- [抽象] --> 类

类是一个模板，是描述共同特征的一个模板，那么共同特征包括什么呢？

潘长江对象：

名字：潘长江

身高：165cm

打篮球：非专业的，自己玩呢，无所谓呢。

学习：考试80分

姚明对象：

名字：姚明

身高：240cm

打篮球：NBA专业球员，打篮球非常棒。

学习：考试100分

共同特征包括哪些？

名字、身高都属于名词。（状态特征）

打篮球、学习都属于动词。（动作特征）

类 = 属性 + 方法

属性来源于：状态

方法来源于：动作

public class 明星类{

// 属性 ---> 状态，多见于名词

名字属性;

身高属性;

//方法--> 动作，多见于动词

打篮球方法(){

}

学习方法(){

}

张三同学、李四同学，他们俩有没有共同的特征呢？

有共同特征，就可以抽象一个类模板出来。

可以定义一个学生类（Student）

public class Student{

// 姓名性别身高

// 方法

public ...... sing(){

}

public ...... dance(){

}

public ...... study(){

}

5 思考：java软件工程师在开发中起到的一个作用是什么？

我们为什么要做软件开发？

说的大一些是为了人民服务。解决现实生活中的问题。

软件开发既然是为了解决现实世界当中的问题，那么首先java软件必须能够模拟现实世界。

其实软件是一个虚拟的世界。

这个虚拟的世界需要和现实世界一一对应，这才叫模拟。

对象和引用：

6 类的定义

6.1 怎么定义一个类，语法格式是什么？

[修饰符列表] class 类型 {

// 类体 = 属性 + 方法

// 属性在代码上以“变量”的形式存在（描述状态）

// 方法的描述动作/行为

}

注意：修饰符列表可以省略。

6.2 为什么属性是“以”变量的形式存在的？

假设我们要描述一个学生：

学生包括哪些属性：

学号：110

姓名："张三"

性别：'男'（true/false）

住址："深圳宝安区"

答案：是因为属性对应的是"数据",数据在程序中只能放到变量中。

结论：属性其实就是变量。

变量的分类还记得吗？

变量根据出现的位置进行划分：

方法体当中声明的变量：局部变量。

方法体外声明的变量：成员变量（这里的成员变量就是“属性”。）

6.3 请大家观察学生对象1和学生对象2的共同特征，然后在利用java语言将该“学生类”表述/表达出来。（这里只是表达属性，不表达方法。）

7 关于编译的过程

按说应该先编译Student.java，然后在编译StudenTest.java

但是对于编译器来说，编译Student.java文件的时候没会自动找Student.class,如果没有，会自动编译Student.java文件，生成Student.class文件。

第一种方式：

javac Student.java

javac StudentTest.java

第二种方式:

javac StudentTest.java

第三种方式:

javac *.java

8 在语法的级别上是怎么完成对象的创建的呢？

类名变量名 = new 类名();

这样就完成的对象的创建。

9 什么是实例变量？

对象又被称为实例？

实例变量实际上就是：对象级别的变量。

public class 明星类{

double height;

}

身高这个属性所有的明星对象都有，但是每一个对象都有"自己的身高值"。

假设创建10个明星对象，height变量应该有10份。

所以这种变量被称为对象级别的变量。属于实例变量。

实例变量在访问的时候，是不是必须先创建对象。

实例变量都储存在哪里？

实例变量都在堆内存的对象内部。

10 对象和引用的区别？

对象是通过new出来的，在堆内存中存储。

引用是：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象。

案例：

创建一个对象

1 观察学生对象的共同特征（只观察属性）

有哪些共同特征：

学号：采用int类型

姓名：采用String类型

年龄：采用int类型

性别：采用char或者boolean类型

住址：采用String类型

2 以上是分析总结的结果，可以开始写代码了：

定义Student类，编写成员变量作为属性

3 变量有一个特点：

必须先声明，再赋值，才能访问。

成员变量可以不手动赋值。

Student既是一个类名，同时又是一个“类型名”属于引用数据类型。

变量必须先声明，再赋值才能访问。

注意：对于成员变量来说，没有手动赋值时，系统默认赋值

赋的值都是默认值，那么默认值是什么？

类型默认值

byte 0

short 0

int 0

long 0L

float 0f

double 0d

boolean flase

char \u0000

String null

分析：对于成员变量来说，是不是应该一个对象有一份

李四有李四的学号

张三有张三的学号

李四和张三的学号不一样。所以应该有两块不同的内存空间。

public class Student{// 这个程序编译之后，会生成Student.class字节码文件

// 属性

// 学号(成员变量)

// 实例变量是一个对象一份

int no; // 这种成员变量又被成为“实例”变量

// 姓名

String name;

// 年龄

int age;

// 性别

boolean sex;

// 住址

String addr;

}

引用这个对象

对象的创建和使用

public class StudentTest{

public static void main(String[] args){

// 局部变量

// 错误：可能尚未初始化变量k

int k;

System.out.println(k);

// 访问学生姓名可以直接通过类名吗？

// 学生姓名是一个实例变量，实例变量是对象级别的变量。

// 是不是应该先有对象才能说姓名的事。

// 不能通过类名来直接访问实例变量。

//System.out.println(Student.name)

int i= 100;

// 在这里可以访问Student类吗？

// 当然可以啦。

创建对象的语法是什么？

目前死记硬背，先记住。后面你就理解了

new 类名();

类是模板，通过一个类，是可以创建n多个对象。

new是一个运算符。专门负责对象的创建。

Student s1 = new Student();

和

int i = 100;

解释一下：

i是变量名

int是变量的数据类型

100是具体的数据

s1是变量名（不能叫做对象。s1只是一个变量名字）

Student是变量s1的数据类型(引用数据类型)

new Student() 这是一个对象。（学生类创建出来的学生对象。）

数据类型包括两种：

基本数据类型：byte short int long float double boolean char

引用数据类型：String Student......

java中所有的“类”都属于引用数据类型。

// s1属于局部变量吗？当然是。

// 局部变量存储在栈内存当中。（栈主要存储局部变量）

// s1这个局部变量叫做引用。

Student s1 = new Student(); // 和int i = 10; 是一个道理

// 怎么访问实例变量？

// 语法：引用实例变量名

System.out.println(s1.no);

System.out.println(s1.name);

System.out.println(s1.age);

System.out.println(s1.sex);

System.out.println(s1.addr);

// 程序执行到这里，我可以修改s1的学号吗？

// 通过"="赋值的方式将内存中的实例变量的值修改一下。

s1.no = 110;

s1.name = "张三";

s1.age = 20;

s1.sex = true;

s1.addr = "深圳宝安区";

System.out.println("学号=" + s1.no);

System.out.println("姓名=" + s1.name);

System.out.println("年龄=" + s1.age);

System.out.println("性别=" + s1.sex);

System.out.println("地址=" + s1.addr);

s1.addr = "山东省烟台市";

System.out.println("地址=" + s1.addr);

System.out.println("---------------------------------");

// 在通过该类创建一个全新的对象

// s2也属于局部变量吗？当然是。

// s2这个局部变量叫做引用。

Student s2 = new Student();

System.out.println(s2.no);

System.out.println(s2.name);

System.out.println(s2.age);

System.out.println(s2.sex);

System.out.println(s2.addr);

// 以上的这个程序就相当于通过Student类实例化了2个Student对象。

// 创建对象的个数没有限制，可以随意。只要有模板类就行。

// 2个对象都属于学生类型。

}

public static void method(){

// i s1 s2都是main方法中的局部变量，在这里是无法访问的。

System.out.prtinlnt(i);

System.out.prtinlnt(s1);

System.out.prtinlnt(s2);

}

难度较大的案例：

用户类：

public class User{

    // 类=属性+方法
    // 以下3个都是属性，都是实例变量。（对象变量。）

    // 用户id
    // int是一种基本数据类型
    int id; // 实例变量

    // 用户名
    // String是一种引用数据类型
    String username; // 实例变量

    // 家庭住址
    // Address是一种引用数据类型
    // addr是成员变量并且还是一个实例变量
    // addr是否是一个引用呢？是。addr是一个引用。
    Address addr;
}

// 实例变量都存储在哪里？
// 实例变量都在堆内存的对象内部。

// 方法体外，类体内定义的变量叫做：成员变量。

地址类：

// 住址类
public class Address{

    // 一个家庭住址有3个属性。

    // 城市
    String city; // 实例变量

    // 街道
    String street;

    // 邮编
    String zipcode;
}

测试类:

/*
    到目前为止，如果什么也没听懂，怎么写代码？
        记住一个知识点就行，可以后期慢慢学习画图。
            记住一句话：里面有什么就能“点”什么。

            所有的实例变量（属性）都是通过“引用.”来访问的。
    
    引用和对象怎么区分？
        “引用”是啥？是存储对象内存地址的一个变量。
        “对象”是啥？堆里new出来的。
    
    通俗一点：
        只要这个变量中保存的是一个对象的内存地址，那么这个变量就叫做“引用”。
    
    思考：
        引用一定是局部变量吗？
            不一定。
*/
public class Test{
    public static void main(String[] args){

        //报错了。id是实例变量，必须先创建对象，通过“引用.”的方式访问。
        /*
            User u = new User();
            u是引用。
        */
        //System.out.println(User.id);

        

        /*
        int i = 100;
        int j = i; // 原理：会将i中保存的100复制一份，传给j变量。
        */
        
        // 家庭住址对象
        Address a = new Address();
        a.city = "北京";
        a.street = "大兴区";
        a.zipcode = "121221";
        
        // 用户对象
        User u = new User();
        System.out.println(u.id); // 0
        System.out.println(u.username); // null
        System.out.println(u.addr); // null

        u.id = 11111;
        u.username = "zhangsan";
        u.addr = a;

        // 思考一个问题：
        // 我想直到zhangsan他是哪个城市的，代码应该怎么写？
        System.out.println(u.username + "是"+u.addr.city+"城市的！");

        // u.addr.city 这行代码可否拆分呢？u.addr.city 节省变量。
        // 拆分成以下代码和以上效果完全相同，原理完全相同，不同的是以下代码多了两个变量。
        Address ad = u.addr;
        String zhuZhi = ad.city;

        System.out.println(zhuZhi);

        //-----------------------是否理解以下代码---------------------------
        int x = 100;
        // = 代表赋值运算，“赋值”中有一个“值”
        // x变量中的值是100. 将100复制一份给y
        // 表示：将x变量中保存的值100复制一份给y
        int y = x;

        //-----------------------是否理解以下代码---------------------------
        Address k = new Address(); // Address k = 0x1111;
        Address m = k; // 这里表示将k变量中保存的0x1111复制了一份传给了m变量。

    }
}

posted @ 2020-06-05 23:56 xlwu丶lz 阅读(202) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

对象（类和对象的理解） 及 对象的理解和使用

公告

对象（类和对象的理解）及对象的理解和使用