Java对象知识梳理

分手后的思念是犯贱 2022-05-16 13:18 255阅读 0赞

## 面向对象的概述 ##

“面向对象”(英语：Object Oriented,简称OO)是一种以事物为中心的编程思想。面向对象程序设计（英语：Object-oriented programming，缩写：OOP），是一种程序开发的方法。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。

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

## 面向对象与面向过程对比 ##

“万物皆对象”。  
     买电脑  
          面向过程  
             1：查资料  
             2：电脑城砍价  
             3：被黑  
             4：痛苦归来  
          面向对象  
            1：找对象。老师  
            2：老师.砍价  
            3：老师.检测电脑  
            4：电脑成功购买

## 面向过程 ##

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

## 对象 ##

对象（object）代表现实世界中可以明确标识的一个实体。例如：一个学生、一张桌子、一间教室，一台电脑都可以看做是一个对象。每个对象都有自己独特的状态标识和行为  
对象的属性（attribute，或者状态（state）），学生有姓名和学号，该学生特有的姓名和学号就是该学生（对象）的属性。  
对象的行为（behavior），是由方法定义，调用对象的一个方法，其实就是给对象发消息，要求对象完成一个动作。可以定义学生对象具备学习的行为。学生对象可以调用学习的方法，执行学习的动作

## 面向对象的特征 ##

封装(encapsulation)  
继承(inheritance)  
多态(polymorphism)  
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。  
设计的过程：其实就是在管理和维护对象之间的关系.

## 使用java来描述事物 ##

案例：通过Java语言定义一个汽车类，并生产出汽车，有颜色，轮胎个数， 有运行的功能。  
分析：  
如何描述现实世界中的事物，描述该事物的属性和行为，汽车具有颜色和轮胎数的属性，具备运行的行为。  
如何使用Java语言进行转换？  
根据对应关系：  
属性：类中的成员变量  
行为：类中的成员函数  
那么定义Java类就是定义一个类的成员。汽车类具备的成员是：颜色，轮胎数，运行方法。  
Car类定义流程：  
  1.使用class 关键字 定义类，  
      1.class空格 类名。类名就是标识符，命名规则，单词的首字母大写，多个单词的首字母大写。注意：不是规定，但是最好遵守  
      2.类名后紧跟一对\{\}表示类的开始和结束。  
  2.汽车有轮胎数 int num;  
      1.不需要给num初始化值，因为汽车轮胎数不确定，有4，有6，有8。  
  3.有颜色 String color  
      1.为什么使用String 例如定义颜色”红色”是字符串类型。  
      2.也不需要初始化值。  
  4.跑的行为(方法、函数) void run()\{\}  
      1.方法中执行输出语句。syso(“跑啦。。。。”);

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

## 对象的创建 ##

创建Car对象  
      1.使用new关键词，就像new数组一样  
      2.需要给型的汽车起一个名字，car  
      3.变量都是有类型的，car属于什么类型，属于Car类型，叫做类类型  
      4.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();  //使用对象的功能。
        }
    }

## 对象成员的调用 ##

有了car对象，调用对象成员  
1.成员变量  
2.成员方法

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";
    
            //对象名.成员方法();
            c.run();
        }
    }

## 局部变量和成员变量 ##

**成员变量:** 定义在类中变量  
**局部变量:** 定义在方法中变量  
**成员变量与局部变量的区别：**

1.应用范围  
    1.成员变量在整个类内都有效    
    2.局部变量只在其声明的方法内有效
    2.生命周期  
    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消失.
    3.存储位置  成员变量属于对象，它存储在堆内，堆内的实体，当没有引用指向其时，才垃圾回收清理 局部变量存在栈内存中，当不在使用时，马上就会被释放。
    4.初始值 
    成员变量它存储在堆中，如果没有赋初值，它有默认值。
            1.整数byte、short、int、long =0；
            2.char='\uoooo'；
            3.boolean =flase；
            4.String =null;
            5.类类型 =null；
            6.数组 =null；
        局部变量，如果要想使用必须手动初始化.
            i.方法中，参数列表中，语句中。
            ii.必须给初始化值，没有初始值，不能使用
            iii.在栈内存中

案例一：

//汽车
    class Car {
        //汽车应该具备的属性
        int num;
        //汽车具备的颜色
        String color;
        //汽车跑的行为
        public void run(){
            System.out.println(num+"轮子的汽车跑起来啦");
        }
    }
    public class CarDemo{
    
        public static void main(String[] args)
        {   //创建实体，并且给该实体起一个名字
            Car c = new Car();
            c.color = "red";
            c.num = 4;
            c.run();//指挥车进行运行。调用格式：对象.对象成员
    
        }
    }

案例二：

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();//指挥车进行运行。调用格式：对象.对象成员
    
        }

案例三：

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

## 匿名对象 ##

匿名对象：没有名字的实体，也就是该实体没有对应的变量名引用。
    匿名对象的用途 
        1，当对象对方法进行一次调用的时候，可以使用匿名对象对代码进行简化。
           为什么只对方法，而不调用属性呢？因为匿名对象调用属性没意义。
           如果对象要多成员进行多次调用，必须给对象起个名字。不能在使用匿名         对象。
        2，匿名对象可以实际参数进行传递。
    匿名对象的简单演示
            1：new Car().run(); 
    内存结构图
            1：new Car().num=5;
            2：new Car().clor="blue";
            两个new 是两个不同的对象，在堆内存中有不同的空间，相互不相互干扰。
    匿名对象的使用
            1：当只使用一次时可以使用匿名对象。执行完毕到;后该对象就变成了垃圾。
            new Car().run();
    执行方法时，可以将匿名对象作为实际参数，传递进去。
    
      5:修黑车
        1：需求
        将小汽车改装成3个轮子的黑车。
            1：汽车类。
            2：汽车修理厂

/* 匿名对象 匿名信 修黑车 汽车类 黑车厂类 把汽车的改成黑色3轮车。 */
    class Car { 
        String name = "smart";
        String color = "red";
        int num = 4;
    
        void run() {
            System.out.println(name + ":" + color + ":" + num + ":跑起来了。。。。");
        }
    
    }
    
    class BlackCarFactory { 
        String name;
        String addr;
    
        Car repairCar(Car c) {
            c.num = 3;
            c.color = "黑色";
            System.out.println("改装成功啦。。。");
    
        }
    }
    
    class Demo1 { 
    
        public static void main(String[] args) {
    
            BlackCarFactory bcf = new BlackCarFactory();
            bcf.name = "幸福修理厂";
            bcf.addr = "天河区棠东东路御富科贸园a栋206";
    
            // 非匿名对象
            Car c = new Car();
            c.run();
            // 改装
            bcf.repairCar(c);
            // 取车
            c.run();
    
            // 匿名对象一,只使用一次：
            // 如下创建了2个对象
            /* * new Car().run(); * * new Car().run(); */
    
            // 匿名对象二，作为实际参数传递
            Car c2 = bcf.repairCar(new Car());
            c2.run();
    
            System.out.println();
        }
    }