Java面向对象（正式进入JAVA语言系统学习）-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_78341216/article/details/136842599

本文介绍了面向对象编程的基础概念，包括面向过程与面向对象的区别，类和对象的定义、组成（成员变量和方法）、构造方法、方法重载，以及对象与引用的传递方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、面向过程和面向对象

1.面向过程的程序设计思想（procedure -Oriented Programming)，简称POP

2.面向对象的程序设计思想（ Object Oriented Programming），简称OOP

面向对象是软件开发中的一类编程风格、开发范式。早期我们大都是采用面向过程思想，但随着科技发展，软件的规模逐渐扩大，问题的复杂性逐步提高，面向过程思想的弊端越来越明显，从而出现了如今主流的面向对象思想。

一、面向过程和面向对象

1.面向过程的程序设计思想（procedure -Oriented Programming)，简称POP

面向过程思想：是分析解决问题的步骤，通过一步一步实现这些步骤来解决问题。其中会将一个问题重复的部分写为函数，来避免代码冗余。

典型语言：c语言。

缺点：只适合于解决简单问题，只针对于单个问题的解决步骤，扩展性差，也不利于后期维护。

2.面向对象的程序设计思想（ Object Oriented Programming），简称OOP

面向对象思想：重点突出类的思想，通过参照现实中的事物，将事物的属性、行为特征抽象出来，用类的方式将相似的属性等表示出来。

典型语言：Java、Python、c++、c#、Ruby 等。

优点：每个事物都有自己的属性、行为，根据相应的类来实现问题。适合复杂问题，扩展性强，便于后期维护。

面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。但是，具体到实现部分的微观操作（就是一个方法），仍然需要面向过程的思路去处理。因此二者是相辅相成的，不能对立看待。

二、类和对象

1.类（发现类）

类：具有相同特征的事物的抽象描述，是抽象的、概念上的定义。

类的声明格式：

访问权限修饰符（public 无）修饰符（final abstract）class（修饰类）类名{

}

比如构建一个汽车类

public class Car {
}

2.类的基本组成

（1）成员变量

类的共有属性，因为变量直接定义在类中，所以称为类的成员，作用于整个类。

在类中定义成员变量可以不赋初值，系统会自动初始化默认值。

常见默认值：

引用类型--null

float --0.0

int、long--0

boolean--false

char --''

以汽车为例，每个汽车都有名字、颜色、价格。

public class Car {
//成员变量
    String name;
    float price;
    String color;
}

（2）成员方法

类的共有行为，相当于一个动词，表示事物的行为功能。

访问权限修饰符修饰符/void 方法名（）{

System.out.println（）；

[return 返回值；]

}

仍旧以汽车为例，汽车可以跑和停。

public class Car {
//成员变量
    String name;
    float price;
    String color;
//成员方法
    public void run(){
        System.out.println("汽车行驶");
    }

    public void stop(){
        System.out.println("汽车停止");
    }
}

3.对象

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

创建和使用对象：
Car bm（变量名）= new Car();

Car bm：使用Car类作为类型声明一个变量bm。

new Car()：使用new 关键字创建对象，然后调用Car类的构造方法初始化对象。

= ：将右边创建的对象地址赋给左边的bm变量。

使用格式：对象名.属性或对象名.方法。（访问对象成员）

public class TestCar {
    public static void main(String[] args) {
        Car bm = new Car();//创建对象
        bm.name = "宝马";//访问对象成员
        bm.price = 300000;
        bm.color = "黑色";
        bm.run();
        bm.stop();
    }
}

4.构造方法

（1）作用

构造方法可以为创建的对象成员变量进行初始化赋值

（2）特点

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

（3）无参构造方法

每个类都有构造方法,如果没有显式地为类定义构造方法，Java将会为该类提供一个默认无参构造方法。

public class Car {
    String name;
    float price;
    String color;
    public Car(){//构造方法--无参

    }
}

创建对象调用无参构造方法，系统先给予对象成员默认值，后需自己给属性赋值

public class TestCar {
    public static void main(String[] args){
        Car ferrari = new Car();//创建对象调用的是无参的构造方法初始化对象成员，先赋予默认值，然后再给属性赋值
        ferrari.name = "法拉利";
        ferrari.price = 1000000;
        ferrari.color = "红色";
    }
}

（4）有参构造方法

自定义参数为属性赋值，只要在一个Java类中定义了一个有参构造方法后，默认的无参构造方法是效。

public class Car {
    public Car(String a,float c,String b){//构造方法--有参
        name = a;
        price = c;
        color = b;
    }
}

有参方法调用类似于c语言函数调用。

public class TestCar {
    public static void main(String[] args){
        Car bwm = new Car("ferral",10000,"black");//创建对象调用有参的，为当前的创建的对象成员进行初始化赋值
    }
}

5.方法重载

方法的重载是指一个类中有多个相名称的方法。调用时区分同名方法，通过方法的参数的个数，类型和顺序不同区分。

（1）参数个数不同

public class Car {
    String name;
    float price;
    String color;
    public Car(){//方法重载--参数个数不同

    }

    public Car(String a,float c,String b){//方法重载--参数个数不同
        name = a;
        price = c;
        color = b;
    }
}

（2）参数顺序不同

public class Car {
    String name;
    float price;
    String color;
    public Car(String a,float c,String b){
        name = a;
        price = c;
        color = b;
    }

    public Car(String a,String b,float c){//方法重载--同名但顺序不同
        name = a;
        price = c;
        color = b;
    }
}

（3）参数类型不同

public class Car {
    String name;
    float price;
    String color;
    public Car(String a,String b,float c){
        name = a;
        price = c;
        color = b;
    }

    public Car(String a,String b,int c){//方法重载--同名但类型不同
        name = a;
        price = c;
        color = b;
    }
}

三、对象与引用

1.对象引用

new Car（）；为我们创建了一个对象在堆空间，但他没有确切的名字，我们无法直接访问它。

为此我们需要通过对象引用来间接访问对象，这时我们就需要创建一个该类的变量，这里以上面内容的汽车Car类为例。

Car car1就是我们创建的一个Car类的变量，通过这个变量，我们便可以通过

Car car1 = new Car（）；访问对象了。而这时如果我们再创建一个变量

Car car2 = new Car（）；并且使

car2 = car1；这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。所以car2也指向的是car1的对象，改变car2的值打两变量的结果只会和car2的结果一样。

代码示例如下：

public class Car {
    String name;
    float price;
    String color;
    public Car(String a,String b,float c){
        name = a;
        price = c;
        color = b;
    }
    public Car(){

    }
    public void print(){
        System.out.println("名字:"+name+" "+"价格:"+price+" "+"颜色:"+color);
    }
}

public class TestCar {
    public static void main(String[] args){
        Car car1 = new Car("ferral","black",10000);
        Car car2;
        car2 = car1;
        car1.print();
        car2.print();

    }
}

给car2赋值后，car1的值也会改变，这证明他们实际上指向的是同一个对象，对象并没被赋复制。

public class TestCar {
    public static void main(String[] args){
        Car car1 = new Car("ferral","black",10000);
        Car car2;
        car2 = car1;
        car2.name = "bwm";
        car2.color = "red";
        car2.price = 30000;
        car1.print();
        car2.print();

    }
}

2.值传递

（1）值传递

值传递--基本类型作为参数传递(形参数类型是基本数据类型)

传的是实参的值给形参，形参改变对实参没影响，两个独立的变量。

public class Value {
    public static void main(String[] args) {
        int i = 10;//实参
        Value value = new Value();
        value.text(i);
        System.out.println("i="+i);//10
    }
    public void text(int j){
        j+=j;//形参
        System.out.println("j="+j);//20
    }
}

互不相关，成员方法打印“20”，主方法打印“10”。

（2）引用传递

引用类型传递--引用数据类型作为参数传递，(形参数类型是引用数据类型参数)

传的是对象的地址。

实参是对象，实参和形参指的是同一个地址，因此改变形参实参也改变。

代码演示：

public class Test {
    public static void main(String[] args) {
        Address address = new Address();
        address.name = "纽约";
        Test test = new Test();
        test.test1(address);
        System.out.println("address="+address.name);//布鲁克林
    }
    public void test1(Address a){
        a.name = "布鲁克林";
        System.out.println("a="+a.name);//布鲁克林
    }
}

不管是成员方法还是主方法，打印结果都是“布鲁克林”。

以上是Java面向对象的初步认识和学习，希望能给大家带来收获和帮助。接下来我会继续带大家了解更多后期详细学习内容！