重温Java（五）：面向对象基础

最新推荐文章于 2022-01-24 00:26:25 发布

小菜鸟入门

最新推荐文章于 2022-01-24 00:26:25 发布

阅读量413

点赞数 1

分类专栏： Java 重温Java系列文章标签：面向过程和面向对象 this关键字类与对象 Java传参机制

本文链接：https://blog.csdn.net/u012187452/article/details/96356793

版权

Java 同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

重温Java系列

5 篇文章 0 订阅

订阅专栏

本章目录
1.面向过程和面向对象
2.类和对象
3.this关键字
4.static关键字
5.参数传值机制
6.包（package）

1.面向过程和面向对象

面向过程和面向对象都是对软件分析、设计和开发的一种思想，它指导着人们以不同的方式去分析、设计和开发软件。

面向过程 思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终实现。这个适合简单任务，不需要过多协作的情况下。比如，如何开车？

面向过程适合简单、不需要协作的事务。但是当我们思考比较复杂的问题，比如“如何造车？”就会发现列出1234这样的步骤，是不可能的。那是因为，造车太复杂，需要很多协作才能完成。此时面向对象思想就应运而生了。

面向对象（Object Oriented Programming， OOP） 思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物？”比如思考造车，我们就会思考“车怎么设计？”，而不是“怎么按步骤造车的问题”，这就是思维方式的转变。

例如，面向对象思想思考造车，发现车由以下对象组成：

轮胎 2. 发动机 3. 车壳 4. 座椅 5. 挡风玻璃

为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤。这样，发现大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是按步骤的，还是离不开面向过程的思想。

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

所以，面向对象和面向过程不是对立的，而是相辅相成的。面向对象离不开面向过程。

面向对象和面向过程的总结：

都是解决问题的思维方式，都是代码组织的方式。
解决简单问题可以使用面向过程
解决复杂问题：宏观上使用面向对象思想把握，微观处理上仍然是面向过程。

面向对象思考方式：
遇到复杂问题，先从问题中找名词，然后确立这些名词哪些可以做为类，再根据问题需求确定类的属性和方法，确定类之间的关系。

建议：

面向对象具有三大特性：封装性、继承性和多态性，而面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。
一个经典的比喻：面向对象就是盖浇饭，面向过程就是蛋炒饭。盖浇饭的好处就是“菜”和“饭”分离。

2.类和对象

类（class）是构造对象的模版，或者图纸，系统根据类的定义来造出对象。我们要造一个汽车，怎么样造?类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。由类构造（construct）对象的过程称为创建类的实例（instance）。

类：我们叫做class。对象：我们叫做Object,instance(实例)。以后我们说某个类的对象，某个类的实例。是一样的意思。

总结
1.对象是具体的事物；类是对对象的抽象;
2.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
3.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。

类的定义方式：

// 每一个源文件必须有且只有一个public class，并且类名和文件名保持一致！但可以有任意数目的非公有类
public class Car {
}
class Tyre { // 一个Java文件可以同时定义多个class
}
class Engine {
}
class Seat {
}

上面的类定义好后，没有任何的其他信息，就跟我们拿到一张张图纸，但是纸上没有任何信息，这是一个空类，没有任何实际意义。所以，我们需要定义类的具体信息。对于一个类来说，一般有三种常见的成员：属性field、方法method、构造器constructor。这三种成员都可以定义零个或多个。

简单的学生类编写

public class SxtStu {
    // 属性（成员变量）
    int id;
    String sname;
    int age;

    // 方法
    void study() {
        System.out.println("我正在学习！");
    }

    // 构造方法
    SxtStu() {
    }
}

属性（field，或者叫成员变量）

属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
在这里插入图片描述
属性定义的格式：

[修饰符]  属性类型  属性名 = [默认值] ;

总结：数值默认值为0；布尔值默认为false；对象引用默认为null。

方法（method）

方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法定义的格式

[修饰符]  方法返回值类型  方法名(形参列表) {
    // n条语句
}

构造方法（constructor）

构造器也叫构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。

声明格式：

[修饰符] 类名(形参列表){
    //n条语句
}

要点：

通过new关键字调用!!
构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
构造器的方法名必须和类名一致!
每个类可以有一个以上的构造器
构造器可以有0或多个参数

实例：定义一个“点”(Point)类用来表示二维空间中的点(有两个坐标)。要求如下：
(1) 可以生成具有特定坐标的点对象。
(2) 提供可以设置坐标的方法。
(3) 提供可以计算该“点”距另外一点距离的方法。

class Point {
    double x, y;

    public Point(double _x, double _y) {
        x = _x;
        y = _y;
    }

    public double getDistance(Point p) {
        return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
    }
}

public class TestConstructor {
    public static void main(String[] args) {
        Point p = new Point(3.0, 4.0);
        Point origin = new Point(0.0, 0.0);
        System.out.println(p.getDistance(origin));
    }
}

调用构造器的具体处理步骤：

所有数据域被初始化默认值（0、false或null）。
按照在类声明中出现的次序，依次序执行所有域初始化语句和初始化块。
如果构造器第一行调用了其他构造器，则执行其他构造器的主体。
执行这个构造器的主体。

补充知识：构造方法的重载

构造方法重载

构造方法也是方法，只不过有特殊的作用而已。与普通方法一样，构造方法也可以重载。

public class User {
    int id; 	 // id
    String name; // 账户名
    String pwd;  // 密码
    public User() {

    }
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public static void main(String[] args) {
        User u1 = new User();
        User u2 = new User(101, "高小七");
        User u3 = new User(100, "高淇", "123456");
    }
}

雷区：如果方法构造中形参名与属性名相同时，需要使用this关键字区分属性与形参。如示例所示：this.id 表示属性id;id表示形参id

类之间的关系
在类之间，最常见的关系有：

依赖（use-a）
聚合（has-a）
继承（is-a）

依赖（dependence），即use-a关系，是一种最明显、最常见的关系；如果一个的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。（应该尽可能将相互依赖的类减至最少，也就是降低类之间的耦合度。）
聚合（aggregation），即has-a关系，是一种具体且易于理解的关系；聚合关系意味着类A的对象包含类B的对象。
继承（inheritance），即is-a关系，是一种用于表示特殊与一般关系的。一般而言，如果类A扩展类B，类A不但包含类B继承的方法，还会拥有一些额外的功能。

对象
对象的三个主要特征：

对象的行为（behavior）：可以对对象施加哪些操作，或可以对对象施加哪些方法
对象的状态（state）：当施加那些方法时，对象如何响应
对象的标识（identity）：如何辨别具有相同行为与状态的不同对象

每个对象都保存着描述当前特征的信息，这就是对象的状态。对象的状态可能会随着调用的方法不同而改变。每个对象都有唯一的身份（identity）。

3.this关键字

对象创建的过程和this的本质

构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步：

分配对象空间，并将对象成员变量初始化为0或空
执行属性值的显示初始化
执行构造方法
返回对象的地址给相关的变量

this的本质就是“创建好的对象的地址”! 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表“当前对象” 。

this最常的用法：

在程序中产生二义性之处，应使用this来指明当前对象；普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
this不能用于static方法中。

this代表“当前对象”示例

public class User {
    int id;        //id
    String name;   //账户名
    String pwd;   //密码

    public User() {
    }

    public User(int id, String name) {
        System.out.println("正在初始化已经创建好的对象：" + this);
        this.id = id;   //不写this，无法区分局部变量id和成员变量id
        this.name = name;
    }

    public void login() {
        System.out.println(this.name + ",要登录！");  //不写this效果一样
    }

    public static void main(String[] args) {
        User u3 = new User(101, "高小七");
        System.out.println("打印高小七对象：" + u3);
        u3.login();
    }
}

运行结果：
在这里插入图片描述

this()调用重载构造方法

public class TestThis {
    int a, b, c;

    TestThis() {
        System.out.println("正要初始化一个Hello对象");
    }

    TestThis(int a, int b) {
        // TestThis(); //这样是无法调用构造方法的！
        this(); // 调用无参的构造方法，并且必须位于第一行！
        a = a;  // 这里都是指的局部变量而不是成员变量
        // 这样就区分了成员变量和局部变量. 这种情况占了this使用情况大多数！
        this.a = a;
        this.b = b;
    }

    TestThis(int a, int b, int c) {
        this(a, b); // 调用带参的构造方法，并且必须位于第一行！
        this.c = c;
    }

    void sing() {
    }

    void eat() {
        this.sing(); // 调用本类中的sing();
        System.out.println("你妈妈喊你回家吃饭！");
    }

    public static void main(String[] args) {
        TestThis hi = new TestThis(2, 3);
        hi.eat();
    }
}

4.static关键字

在类中，用static声明的成员变量为静态成员变量，也称为类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：

为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!!
一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)
在static方法中不可直接访问非static的成员。

静态初始块

构造方法用于对象的初始化!静态初始化块，用于类的初始化操作！在静态初始化块中不能直接访问非static成员。

注意事项：静态初始化块执行顺序

上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们的类的静态初始化块为止。
构造方法执行顺序和上面顺序一样！！

示例

public class User {
    int id;        //id
    String name;   //账户名
    String pwd;   //密码
    static String company; //公司名称

    static {
        System.out.println("执行类的初始化工作");
        company = "北京尚学堂";
        printCompany();
    }

    public static void printCompany() {
        System.out.println(company);
    }

    public static void main(String[] args) {
        User u3 = new User();
    }
}

静态方法
静态方法是一种不能向对象实施操作的方法。例如，Math类的pow方法就是一个静态方法。在运算时，不使用任何Math对象。
静态方法可以访问自身类中的静态域。
注：Java中允许使用对象调用静态方法。但是避免混淆，一般建议使用类名，而不是对象来调用静态方法。

在以下两种情况使用静态方法：

一个方法不需要访问对象状态，其所需参数都是通过显示参数提供。
一个方法只需要访问类的静态域

5.参数传值机制

Java中，方法中所有参数都是“值传递”，也就是“传递的是值的副本”。也就是说，我们得到的是“原参数的复印件，而不是原件”。因此，复印件改变不会影响原件。

基本数据类型参数的传值：传递的是值的副本。副本改变不会影响原件。
引用类型参数的传值：传递的是值的副本。但是引用类型指的是“对象的地址”。因此，副本和原参数都指向了同一个“地址”，改变“副本指向地址对象的值，也意味着原参数指向对象的值也发生了改变”。

示例：

public class User {
    int id;        //id
    String name;   //账户名
    String pwd;   //密码

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public void testParameterTransfer01(User u) {
        u.name = "高小八";
    }

    public void testParameterTransfer02(User u) {
        u = new User(200, "高三");
    }

    public static void main(String[] args) {
        User u1 = new User(100, "高小七");

        u1.testParameterTransfer01(u1);
        System.out.println(u1.name);

        u1.testParameterTransfer02(u1);
        System.out.println(u1.name);
    }
}

6.包（package）

我们通过package实现对类的管理，package的使用有两个要点：

通常是类的第一句非注释性语句。
包名：域名倒着写即可，再加上模块名，便于内部管理类。
例如：com.baidu.test

注：写项目时都要加包，不要使用默认包。使用包的主要原因是确保类名的唯一性。

JDK中主要的包
在这里插入图片描述

7.导入类import

如果我们要使用其他包的类，需要使用import导入，从而可以在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。import后，便于编写代码，提高可维护性。

注意要点：

Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：java.util.Date date = new java.util.Date();

静态导入
静态导入(static import)是在JDK1.5新增加的功能，其作用是用于导入指定类的静态属性，这样我们可以直接使用静态属性。

//以下两种静态导入的方式二选一即可
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性

public class Test2{
    public static void main(String [] args){
        System.out.println(PI);
        System.out.println(random());
    }
}

小菜鸟入门

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
重温Java（五）：面向对象基础

本章目录1.面向过程和面向对象2.类和对象3.this关键字4.static关键字5.参数传值机制6.包（package）1.面向过程和面向对象面向过程和面向对象都是对软件分析、设计和开发的一种思想，它指导着人们以不同的方式去分析、设计和开发软件。面向过程思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终实现。这个适合简单任务，不需要过多协作...
复制链接

扫一扫