Java——面向对象

面向过程和面向对象

● 面向过程：procedure oriented programming 缩写 POP

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

● 面向对象：object oriented programming 缩写 OOP面向对象的编程语言

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

• 二者关系

面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观 上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过 程的思维方式。面向对象如果离开了面向过程，就无法实现真正的落地， 成为无源之水。

Java类

● 什么是类？

类是一个模板，它描述一类事物的属性和行为的集合.

类是表示一个客观世界某类群体的一些基本特征抽象

• 类的结构

Ø成员变量：事物属性的描述；

Ø方法:事物的行为；（可以做的事情）

Ø构造方法：初始化对象；

Ø内部类：

即在类体中声明的类。

Ø块：一段没有名称的代码块

Java类的定义

类的声明格式为:
[访问权限修饰符] [修饰符] class Car{
}

访问修饰符有两种public，无(默认)

• 修饰符：final,abstract

• 关键字class用来定义一个类

• Java类名的命名规范:

类名首字母大写,见名知意,驼峰表示

• 第二步：发现类的共有属性(成员变量)

汽车类共有的特征：

1. 颜色

2. 名称

3. 型号

… …

名词

public class Car{ 

//成员变量定义 

String name; //名称 

String color; // 颜色 

float price;//价格 

}

声明成员变量的格式为：

[访问权限修饰符] [修饰符] type attr_name [=defaultValue] ;

1. 成员变量是定义在类中，方法体之外的变量。

2. 成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

3. 在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

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

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

6. 成员变量的作用范围为整个类体。

• 第三步：发现类的方法

汽车类共有的行为：

1. 启动

2. 行驶

3. 刹车

… …

动词

public class Car{
//成员变量定义
String name; //名称
String color; // 颜色
float price;//价格

方法声明格式为:
[访问权限修饰符] [修饰符]/ void start(){
System.out.println(“汽车启动”);
[return 返回值;]
}
}

Java对象

● 对象：对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例

● 对象的创建和使用

Car x1 = new Car();

Car x1:使用Car类作为类型声明一个变量x1.

new Car():使用new + Car类构造方法创建对象.

= :将右边创建的对象地址 赋给 左边的x1变量

使用x1变量访问对象中的成员变量和成员方法.

● 同一类的每个对象有不同的成员变量存储空间。

● 同一类的每个对象共享该类的方法。

● 总结类和对象

类是一类事物的抽象概念,是一个模型.

对象是由这个模型所创造的一个个具体存在的,实实在在存在的实例.

所以创建对象的过程也叫实例化对象.

• 现实生活中先有对象后有类,而编程时先设计类后创建对象

按照位置变量分为：

● 成员变量：

成员变量是定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。在定义成

员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。成员变量

在创建对象的时候会从类中复制一份到对象中。

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

成员变量的作用范围为整个类体。

● 局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。

局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。局部变量

在使用前必须初始化赋值。

变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

l 成员方法：成员方法是定义在类中。

语法格式：

修饰符 返回值类型 方法名( 参数列表) {

方法体语句；

[return 返回值]

}

构造方法

构造方法:用来初始化对象的方法

构造方法名与类名相同,且没有返回值,且不需要使用void修饰。

作用:在构造方法中为创建的对象初始化赋值, 在创建一个对象的时候，至少要调用一个构造方法。
每个类都有构造方法。如果没有显式地为类定义构造方法，
Java将会为该类提供一个默认 构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。

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

例：

public class Car{ 

public Car(){ } 

public Car(String name){ // 这个构造方法有一个参数：name } 

} 

例：创建Car类的对象 

Car car1 = new Car(); 

Car car2 = new Car(“宝马”)

方法的重载

方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。

● 参数不同（可以有三方面的不同）

• 数量不同

• 类型不同

• 顺序不同

● 调用时，会根据不同的参数表选择对应的方法。

注意：方法重载跟方法的返回值类型没有任何关系

package com.java2022_8_2.javaDemo;

/**
 * @description:
 * @author: 博弈
 * @time: 2022/8/7 19:31
 * @since 1.0
 */
public class Car01 {
    /*
    * 发现定义属性（成员变量） 名词
    * */
    String name;
    String color;
    int money;
    char a;

    public Car01(){
        System.out.println("car01类无参构造");
    }
    public Car01(String na,int pri){
        System.out.println("有2个参数的构造方法");
        name=na;
        money=pri;
    }

    /*
    * 发现行为 （成员方法） 动词
    * */
    public void run(){
        System.out.println(name+"可以跑"+a+"8");
    }

    //方法的重载和返回值是没有任何关系的
    //方法的重载是☞在一个类中 具有相同的名字 但是参数不同的多个方法
    //参数的不同表现在三个方面：数量，类型，顺序
    //调用时 会根据参数的不同选择对应的方法
   /* public int run(){
        System.out.println(name+"可以跑"+a+"8");
    }*/
}

package com.java2022_8_2.javaDemo;

/**
 * @description:
 * @author: 博弈
 * @time: 2022/8/7 19:33
 * @since 1.0
 */
public class Demo1Tset {
    public static void main(String[] args) {
        /*
        * 实际中，先有对象，后有类。
        *  程序设计中 先设计的类，然后根据类创建对象
        *
        * new Car01(); 以Car01类为模板在内存中创建出来一个具体的对象/实例
        * Car01 bm 定义了一个Car01类的变量
        *
        * = ：把对象赋给了bm变量，bm表示具体的对象
        *
        * */
        Car01 bm=new Car01();
        bm.color="蓝色";
        bm.money=909;
        bm.name="宝马";
        bm.run();

        Car01 dz=new Car01("大众",76);
        System.out.println(dz.money);
        System.out.println(dz.name);
    }
}

对象与引用

基本类型传递的是该数据值本身；引用类型传递的是对对象的引用，而不是对象。

package com.java2022_8_2.javaDemo;

/**
* @description:
* @author: 博弈
* @time: 2022/8/13 10:35
* @since 1.0
*/
public class Demo2 {
   public static void main(String[] args) {

     /*  //值传递
       int a=10;
       new Demo2().test(a);
       System.out.println(a);//10
   }

   public void test(int b){
       b=20;
   }
*/

       //引用传递
       Car01 car1=new Car01();
       car1.name="宝马";
       new Demo2().test(car1);//引用对象实际传递的不是对象，传递的是对象的地址
       System.out.println(car1.name);//大奔
   }

   public void test(Car01 car2){
       car2.name="大奔";
   }
}