java基础6 面向对象的详解

本文知识点（目录）：

    1.1、万物皆对象
    1.2、面向对象的概述
    1.3、面向对象(java语言)与面向过程(C语言)对比
    1.4、面向过程
    1.5、对象
    1.6、面向对象的特征
    1.7、使用java来描述事物
    1.8、对象的创建
    1.9、对象成员的调用
    1.10、局部变量和成员变量
    1.11、内存分析
    1.12、匿名对象

1.1 万物皆对象

我们是怎么认识世界的？

人类从小就不断的接触到各种各类存在世界上的各种生物，然后通过事物的公共特性，将它们归类，所以以后就不会出现见到猫叫老虎。那么我们在现实生活中，是通过具体的某个事物归纳总结它们的公共特性然后产生类那么类就描述了该种事物的的共别。性，相当于造事物的图纸，我们可以根据这个图纸去做出具体的实体对象。

对象：在现实生活中存在具体的一个事物。;

类：实际就是对某种类型事物的共性属性与行为的抽取。

人类认识世界：对象----à类。

在java中：类 -----à对象。

使用计算机语言就是不断的在描述现实生活中的事物。

java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

对象即是该类事物实实在在存在的个体。

类与对象的关系如图

可以理解为：

类就是图纸

汽车就是堆内存中的对象

1.2 面向对象的概述

“面向对象”(英语：Object Oriented,简称OO)是一种以事物为中心的编程思想。

面向对象程序设计（英语：Object-oriented programming，缩写：OOP），是一种程序开发的方法。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。

面向对象时相对于面向过程而已的（c则是一个典型的面向过程的语言），站在面向对象的角度去看问题，你则是对象的动作的指挥者。如果站在面向过程的角度去看问题，你则是动作的执行者。

1.3 面向对象(java语言)与面向过程(C语言)对比

“万物皆对象”。
　　1：买电脑
　　　　1：面向过程
　　　　　 1：查资料
　　　　　　2：电脑城砍价
　　　　　　3：被黑
　　　　　　4：痛苦归来
　　　　2：面向对象
　　　　　　1：找对象。老师
　　　　　　2：老师.砍价
　　　　　　3：老师.检测电脑
　　　　　　4：电脑成功购买
　　2：吃饭
　　　　1：面向过程
　　　　　　1：自己动手做
　　　　　　2：买菜
　　　　　　3：洗菜
　　　　　　4：煮饭炒菜
　　　　　　5：正在吃饭
　　　　2：面向对象
　　　　　　1：找专业对象
　　　　　　2：餐馆.点餐
　　　　　　3：餐馆，做饭
　　　　　　4：正在吃饭
等等............

1.4 面向过程

强调的是功能行为，面向过程”是一种以过程为中心的编程思想。“面向过程”他们不支持丰富的“面向对象”特性（比如继承、多态），就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向过程在这一系列工作的执行中，强调的是工作的执行。

1.5 对象

对象（object）代表现实世界中可以明确标识的一个实体。例如：一个学生、一张桌子、一间教室，一台电脑都可以看做是一个对象。每个对象都有自己独特的状态标识和行为

对象的属性（attribute，或者状态（state）），学生有姓名和学号，该学生特有的姓名和学号就是该学生（对象）的属性。

对象的行为（behavior），是由方法定义，调用对象的一个方法，其实就是给对象发消息，要求对象完成一个动作。可以定义学生对象具备学习的行为。学生对象可以调用学习的方法，执行学习的动作

1.6 面向对象的特征

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程：其实就是在管理和维护对象之间的关系.

1.7 使用java来描述事物

案例：通过Java语言定义一个汽车类，并生产出汽车，有颜色，轮胎个数，有运行的功能。

分析：

如何描述现实世界中的事物，描述该事物的属性和行为，汽车具有颜色和轮胎数的属性，具备运行的行为。

如何使用Java语言进行转换？

根据对应关系：

属性：类中的成员变量

行为：类中的成员函数

那么定义Java类就是定义一个类的成员。汽车类具备的成员是：颜色，轮胎数，运行方法。

Car类定义流程：

使用class 关键字定义类，
1. class空格类名。类名就是标识符，命名规则，单词的首字母大写，多个单词的首字母大写。注意：不是规定，但是最好遵守
2. 类名后紧跟一对{}表示类的开始和结束。
汽车有轮胎数 int num;
1. 不需要给num初始化值，因为汽车轮胎数不确定，有4，有6，有8。
有颜色 String color
1. 为什么使用String 例如定义颜色"红色"是字符串类型。
2. 也不需要初始化值。
跑的行为(方法、函数) void run(){}
1. 方法中执行输出语句。syso("跑啦。。。。");

public class Car {
    
String color;// 成员变量
    int num; // 成员变量

    // 成员函数
    void run() {
        System.out.println(color + "的车，轮胎数：" + num + "个，跑起来了");
    }
}

1.8 对象的创建

创建Car对象

使用new关键词，就像new数组一样
需要给型的汽车起一个名字，car
变量都是有类型的，car属于什么类型，属于Car类型，叫做类类型
Car car=new Car();

图纸画好了，类定义成功了。如何根据图纸生产汽车，在Java中如何根据类来生产一个对象。

Java中生产汽车比较简单，通过一个关键字”new”, 通过 new Car(); 就在内存中产生了一个实体，汽车对象就生产出来了。

汽车对象生产出来后，还没有名字，为了方便使用，需要起一个名字。就用小写的C 来表示新车的名字。

Java中的变量都需要有类型。那么c 是什么类型呢？c 是Car类型，所以c也叫做类类型变量。

class CarDemo {
    public static void main(String[] args) {
        // java 中创建对象，使用new关键字。在堆内存中开辟了空间。产生了一个实体。
        Car c = new Car();
        //为了方便使用生产的汽车，就起了一个名字。
        //那么c是什么类型,是Car类型。叫做类类型变量。
        //注意 c是持有的引用，新生产的汽车并没有直接赋值给c，持有的只是一个引用。c就想电视遥控器一样。
        c.run();  //使用对象的功能。
    }
}

1.9 对象成员的调用

有了car对象，调用对象成员

成员变量
成员方法

public class CarDemo {
    public static void main(String[] args) {
        Car c = new Car(); //创建对象
        //对象名.成员变量名将返回成员变量中存储的数值
        int num=c.num; 
        System.out.println(num);
        
        //对象名.成员变量名,也可以给成员变量赋值
        c.num = 4;
        c.color = "black";
        
        //对象名.成员方法();  //调用run()方法
        c.run();
    }

    public class Car {
    
    String color;// 成员变量
    int num; // 成员变量

    // 成员函数
    void run() {
        System.out.println(color + "的车，轮胎数：" + num + "个，跑起来了");
    }
}

1.10 局部变量和成员变量

成员变量: 定义在类中变量

局部变量: 定义在方法中变量

成员变量与局部变量的区别：

A.定义位置区别:
　　1.成员变量在方法之外,类之内的
　　2.局部变量方法之内

B.作用上的区别:
　　1.成员变量作用是描述一类公共属性的;
　　2.局部变量的作用是提供一个变量给方法内部使用

C.生命周期的区别:
　　1.随着对象的创建而存在,随着对象的消失而消失
　　2.局部变量在调用对应的方法是执行到创建该变量的语句时,局部变量一旦出了自己的作用域,那么马上从内存中消失

D.初始值
　　1.成员变量有默认初始值.
　　2.局部变量没有默认初始值,必须先赋初始值才能使用.

void show(int id){    
    for(int i=0;i<10;i++){
         for(int j=0;j<10;j++){
               System.out.println(id);
         }
    }
}

这时候 id,i,j者是在方法内声明的，全是局部变量

j当里层for循环执行它的生命周期开始，当里层for结束，j消失

i当外层for循环执行它的生命周期开始，当外层for结束，j消失

id在方法被调用时开始，方法结束时，id消失.

存储位置成员变量属于对象，它存储在堆内，堆内的实体，当没有引用指向其时，才垃圾回收清理局部变量存在栈内存中，当不在使用时，马上就会被释放。
初始值

成员变量它存储在堆中，如果没有赋初值，它有默认值。

整数byte、short、int、long = 0；
char = '\uoooo'；(一个空格)
boolean = flase；
String = null;
类类型 = null；
数组 = null；

局部变量，如果要想使用必须手动初始化.

方法中，参数列表中，语句中。
必须给初始化值，没有初始值，不能使用
在栈内存中

1.11 内存分析

案例1:

 1 //汽车
 2 class Car {
 3     //汽车应该具备的属性
 4     int num;
 5     //汽车具备的颜色
 6     String color;
 7     //汽车跑的行为
 8     public void run(){
 9         System.out.println(num+"轮子的汽车跑起来啦");
10     }
11 }
12 public class CarDemo{
13     
14     public static void main(String[] args)
15     {    //创建实体，并且给该实体起一个名字
16         Car c = new Car();
17         c.color = "red";
18         c.num = 4;
19         c.run();//指挥车进行运行。调用格式：对象.对象成员
20         
21     }
22 }

解析: 一创建Car这个对象, 还没给color和num初始化前,他们的默认值分别为 color = NULL, num = 0 , string的默认值为NULL, int的默认值为0

案例2:

public static void main(String[] args){   
　　　　 //创建实体，并且给该实体起一个名字
        Car c = new Car();
        Car c1 = new Car();
        c.color = "red";
        c1.num = 4;
        System.out.println(c1.color);
        c.run();//指挥车进行运行。调用格式：对象.对象成员
        
}

解析:可以参考案例1的解析

1.12 匿名对象

1：匿名对象：没有名字的实体，也就是该实体没有对应的变量名引用。(没有引用类型指定的对象)

1.2：匿名对象要注意的事项:
1.我们一般不给匿名对象赋予属性值, 因为永远都无法获取到值
2.两个匿名对象用远不可能是同一个对象
1.3：匿名对象好处: 简化书写.

1.4：匿名对象的用途

　　1，当对象对方法进行一次调用的时候，可以使用匿名对象对代码进行简化。

　为什么只对方法，而不调用属性呢？因为匿名对象调用属性没意义。

　如果对象要多成员进行多次调用，必须给对象起个名字。不能在使用匿名对象。

　　2，匿名对象可以实际参数进行传递。

2：匿名对象的简单演示

　　1：new Car().run();

3：内存结构图

　　1：new Car().num=5;

　　2：new Car().clor="blue";

　　两个new 是两个不同的对象，在堆内存中有不同的空间，相互不相互干扰。

4：匿名对象的使用

　　1：当只使用一次时可以使用匿名对象。执行完毕到;后该对象就变成了垃圾。

　　new Car().run();

2:执行方法时，可以将匿名对象作为实际参数，传递进去。

案例: 修黑车

1：需求

将小汽车改装成3个轮子的黑车。

1：汽车类。

2：汽车修理厂

 1 /*
 2  匿名对象
 3  匿名信
 4  修黑车
 5  汽车类
 6  黑车厂类
 7  把汽车的改成黑色3轮车。
 8 
 9  */
10 class Car {
11     String name = "smart";
12     String color = "red";
13     int num = 4;
14 
15     void run() {
16         System.out.println(name + ":" + color + ":" + num + ":跑起来了。。。。");
17     }
18 
19 }
20 
21 class BlackCarFactory {
22     String name;
23     String addr;
24 
25     Car repairCar(Car c) {
26         c.num = 3;
27         c.color = "黑色";
28         System.out.println("改装成功啦。。。");
29         
30     }
31 }
32 
33 class Demo1 {
34 
35     public static void main(String[] args) {
36 
37         BlackCarFactory bcf = new BlackCarFactory();
38         bcf.name = "幸福修理厂";
39         bcf.addr = "天河区棠东东路御富科贸园a栋206";
40 
41         // 非匿名对象
42         Car c = new Car();
43         c.run();
44         // 改装
45         bcf.repairCar(c);
46         // 取车
47         c.run();
48 
49         // 匿名对象一,只使用一次：
50         // 如下创建了2个对象
51         /*
52          * new Car().run();
53          * 
54          * new Car().run();
55          */
56 
57         // 匿名对象二，作为实际参数传递
58         Car c2 = bcf.repairCar(new Car());
59         c2.run();
60 
61         System.out.println();
62     }
63 }

匿名对象的总结：

1. 匿名对象设置的属性永远无法获取？没有引用变量指向那个对象。

2. 任何两个匿名对象使用==比较，永远返回false。

3. 匿名对象主要应用于实参。

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：http://www.cnblogs.com/dshore123/p/8691490.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）

posted @ 2018-04-02 11:14 DSHORE 阅读(1845) 评论(0) 编辑收藏举报

刷新页面返回顶部

DSHORE

攻城狮在东莞相亲，成功后即将上线！