javaSE第四章_【面向对象(1)类,方法,重载】

javaOpp

面向过程和面向对象的设计思想

面向过程：procedure oriented programming (POP)

• 分析出解决问题所需要的步骤，然后把步骤一步一步实现。
• 直接关注流程

把大象装进冰箱.

洗衣服

1.打开洗衣机盖 ()

2.衣服扔进去()

3.关闭洗衣机盖()

面向对象：object oriented programming (OOP)

• 以分类的方式进行思考和解决问题。
• 先对整体关系作出分类，然后根据不同的类深入细节的处理。
• 符合人类的认知习惯。

洗衣机

开盖()

关盖()

洗衣服()

人

操作()

面向过程和面向对象是相辅相成的,面向对象是宏观的设计,面向过程是具体的实现

人类 人 张三
先有人，后有人类
先有对象,后有类

---

对象-指的是一个具体存在的…

java 类

类就是对同一类事物(具体存在的) 共有的属性(名词)行为(动词)的定义(抽象)

类是一个模板 根据某个类 来创建这个类的具体实例(对象)

• 像int一样，是型别一种，new了一个…类（型别）的对象

• 依照对象的需求开发类别

• 定义变量，对象识别，对象转型，
  是一个种类 制作具体对象的说明书

• 有成员变量，方法
  局部变量，方法

• 开发类别：class 类别（）

类的结构

• 成员变量：事物属性的描述；
• 方法:事物的行为；（可以做的事情）
• 构造方法：用于创建对象；
• 内部类： 即在类体中声明的类。
• 块：一段没有名称的代码块

类的定义

• 发现类(设计类)
• 定义类的成员变量：类的共有属性（名词）
  [修饰符] 类型 变量名 = [值]
• 定义类的成员方法：类的行为（动词）
  访问权限修饰符 返回值类/void(参数类型 参数名){
  [return 值]
  }

访问修饰符：public，无(默认)
修饰符：final, abstract 关键字class用来定义一个类

public class ClassCar {
    /*
       成员变量 类的属性（名词）
       [修饰符] 类型 变量名 = [值]
    */
    String name;
    String color;
    float price;
    /*
      成员方法 类的行为（动词）
      访问权限修饰符 返回值类/void(参数类型 参数名){
            [return 值]
      }
    */
    //行驶
    public void run(){
        System.out.println("汽车行驶");
    }
    public void stop(){
        System.out.println("汽车刹车");
    }
}

---

对象

对象是类的实例 是概念的具体存在 以类为模板,在内存中创建一个真实存在的实例.

万事万物(现实存在)皆为对象(可以使用的)

• 一群记忆体的集合
  用一个变量（有多个属性）可以管理多个记忆体
  某一个对象是那一个类别的对象
• 对象可以储存大量数据，运算数据
• 有属性和方法

建立对象：new 类别名称（值）

    Car x1 = new Car();

● Car x1: 使用Car类作为类型声明一个变量x1.
● new Car(): 使用new + Car类构造方法创建对象. = :将右边创建的对象地址 赋给 左边的x1变量 使用x1变量访问对象中的成员变量和成员方法
● 同一类的每个对象有不同的成员变量存储空间。
● 同一类的每个对象共享该类的方法。

创建对象简图:

public static void main(String[] args) {
        /*
           使用new关键字来创建对象 new Car 创建Car类的对象
           Car() 使用类的构造方法初始化类
           Car bm 声明一个与构造方法名称相同的类型的变量
           =  把在内存中对象存储的地址 赋值给左边的 bm变量

         */
           Car bm = new Car();
               bm.name = "宝马";
               bm.color = "黑色";
               bm.price=400000f;
               bm.run();
               bm.stop();

           Car bc = new Car();
               bc.name = "奔驰";
               bc.color = "白色";
               bc.price = 500000f;
               bc.run();
               bc.stop();
 
    }

总结类和对象

类是一类事物的抽象概念,是一个模型. 对象是由这个模型所创造的一个个具体存在的,实实在在存在的实例. 所以创建对象的过程也叫实例化对象. • 现实生活中先有对象后有类,而编程时先设计类后创建对

---

参考变量

定义变量型别 建立对象 把对象的位址指派给c 控制这个对象

• 名称 控制对象
• 定义储存对象的记忆体位址，指向等号右边对象的变量
• 变量是储存基本数据类型的值，而参考变量是储存对象的记忆体位址，从而控制对象

---

类中的变量

从数据类型角度分:

基本类型变量: byte short int long float dobule char boolean

引用类型变量: 类 数组 接口…

按照位置划分:

成员变量:

• 直接被类包含

• 成员变量的数据类型可以为基本类型也可以为引用类型

• 可以对成员变量进行初始化赋值(不建议), 如果不初始化,创建对象时,可以调用构造方法使用默认值赋值. 0 0.0 false null

• 成员变量在创建对象的时候会从类中复制一份到对象中。

• 成员变量可以被类中方法、构造方法和特定类的语句块访问

• 成员变量生命周期: 变量什么时候生(对象创建),什么时候死(对象被回收时)

局部变量:

• 在方法(成员方法,构造方法)中 或者代码块中

• 局部变量在使用前必须显示的初始化赋值

• 局部变量生命周期: 变量什么时候生(方法被调用时),什么时候死(方法运行结束 出栈)

• List item

局部变量是有顺序，先定义才能用。成员变量没有顺序性。

---

类中的方法

成员方法：

(非static修饰的) 被对象调用. 完成对象的功能(行为)，定义在类中

构造方法：

为什么要用构造方法?

面向对象的强制要求

- 是创建对象时new方法必须调用的
- 自己不定义时，编译器会默认生成一个

构造方法的作用

用来初始化对象。例如为对象中的属性赋值

• 方法名与类名相同,没有返回值,不需要void修饰

• 每一个类中至少有一个默认无参的构造方法,每次创建对象时至少调用一个.

• 如果显示的定义一个构造方法,默认的就失效了

• 一个类可以有多个构造方法

例： public class Car{ public Car(){ }
public Car(String name){ // 这个构造方法有一个参数：name } }
例：创建Car类的对象 Car car1 = new Car();
Car car2 = new Car(“宝马”)

public class Car {
    String name;
    String color;
    float price;
    //无参的构造方法
    public Car(){
        System.out.println("Car无参的构造方法");
    }
    public Car(String n,String c){
        name=n;
        color=c;
        System.out.println("有参的构造方法String n,Stirng c");
    }
    public Car(float f,String n){
        name = n;
        price = f;
        System.out.println("有参的构造方法String n,float f");
    }
    public Car(String n,String c,float f){
        name = n;
        color = c;
        price = f;
        System.out.println("有参的构造方法String n,String c,float f");
    }
    //行驶
    public  void run(){
        System.out.println(name+"汽车行驶");
    }
    public  void run(int speed){
        System.out.println(name+"汽车行驶");
    }
    //刹车
    public void stop(){
        System.out.println(name+"汽车刹车");
    }

    public void test(){
        int a;
        a=0;
        System.out.println(a);
        String s = "";
        System.out.println(s);
    }
}

test：

public class TestCar {
    public static void main(String[] args) {
     /*
       使用new关键字来创建对象 new Car 创建Car类的对象
       Car() 使用类的构造方法初始化类
       Car bm 声明一个与构造方法名称相同的类型的变量
       =  把在内存中对象存储的地址 赋值给左边的 bm变量

     */
        Car bm = new Car();
        bm.name ="宝马";
        bm.color = "黑色";
        bm.price=400000f;
        bm.run();
        bm.stop();

        Car bc = new Car();
        bc.name = "奔驰";
        bc.color = "白色";
        bc.price = 500000f;
        bc.run();
        bc.stop();

        Car dz = new Car();
        System.out.println(dz.name);
        System.out.println(dz.price);

        //使用有参的构造方法为对象初始化赋值
        Car aodi = new Car("奥迪", "黑色");
        System.out.println(aodi.name);
        System.out.println(aodi.color);
    }

说明第一个创建对象时，默认调用了无参的构造方法，输出了语句

---

方法的重载

同一个类中具有相同的名字，但参数不同的多个方法。
比如上面初始化对象的 无参和有参的构造方法

如何区分方法： 通过参数区分: 参数个数不同, 类型,顺序
调用时，会根据不同的参数表选择对应的方法。

注意：方法的重载与方法返回值类型无关