Java入门2: 面向对象

MangoGO芒狗狗

已于 2024-05-14 23:35:05 修改

阅读量636

点赞数 17

分类专栏： Java入门文章标签： java 开发语言

于 2024-05-13 23:53:52 首次发布

本文链接：https://blog.csdn.net/silencewx1005/article/details/138824689

版权

Java入门专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java入门2: 面向对象

MangoGO 芒狗狗

2 面向对象

对象，万事万物皆为对象。面向对象，就是指从这个对象的整体出发，看它由哪些部件组成，可以做到哪些事情。

比如一个人，他有名字、年龄、性别等属性，也有吃饭、睡觉、工作等行为。我们把这些属性和行为封装在一个对象中，就可以很方便地描述这个人。

面向对象的思想，体现的是人所关注对象的信息聚集在了一个具体的物体上。人们就是通过对象的属性和行为来了解对象。

2.1 类

类是对象的抽象，是对一类对象的描述。通过类可以创建出具有相同属性和行为的对象。比如，人类就是一个类，每个人都是这个类的一个实例。

由此可以总结出类的定义：

类是对象的抽象，是对象的一个模板，它描述一类对象的行为和状态
类是具有相同属性和方法（行为）的对象的集合

属性是对象具有的特征。每个对象的每个属性都拥有特定值，正是对象属性的值来区分不同的对象，比如我们可以通过一个人的身份证定位唯一一个人。

行为是对象能够做的事情，我们通过方法来描述对象的行为。方法就是对象所具有的操作，比如人会走路、会哭泣、会学习等等都是人的行为，也就是人的方法。

类和对象的关系可以总结为：类就是对象的抽象（或者模板），对象就是类的具体（或者实例）。

定义一个类的基本语法如下：

public class ClassName {
    // 属性
    属性1的类型 属性1;
    属性2的类型 属性2;
    ···
    
    // 方法
    方法1
    方法2
    ···
}

定义类名。类名后面跟上大括号，大括号里面就是类的一些信息。上面的 public 为权限修饰符。
编写类的属性。属性的定义在类名后面的大括号里，定义的时候要明确属性的类型。属性可以没有，也可以多个。
编写类的方法。方法也是写在大括号里面。可以定义一个方法或多个方法，当然也可以不定义方法。

public class People {
    double height;
    int age;
    int sex;

    void cry() {
        System.out.println("我在哭");
    }
    void laugh() {
        System.out.println("我在笑");
    }
    void printBaseMes(){
        System.out.println("我的身高是: " + height + "cm");
        System.out.println("我的年龄是: " + age + "岁");
        if (this.sex == 0) {
            System.out.println("我是男性");
        } else {
            System.out.println("我是女性");
        }
    }
}

类型变量是用于描述类的属性和方法的数据类型。在Java中，我们可以使用以下几种常见的类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

2.2 对象

对象创建语法：

类名 对象名 = new 类名();

例如：

People MangoGO = new People();

定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。

public class NewObject {
    public static void main(String[] args) {
        People MangoGO = new People();
        MangoGO.height = 175.5;
        MangoGO.age = 25;
        MangoGO.sex = 0;

        MangoGO.printBaseMes();
    }
}

!java NewObject.java

我的身高是: 175.5cm
我的年龄是: 25岁
我是男性

创建对象后，我们可以通过 对象名.属性名 的方式访问对象的属性，并且可以通过 对象名.方法名() 的方式调用对象的方法。

MangoGO.height = 170;
MangoGO.cry();

上节介绍了成员变量和局部变量，对象的属性就是成员变量，在方法中定义的变量就是局部变量。成员变量可以被本类的所有方法所使用，同时可以被与本类有关的其他类所使用。而局部变量只能在当前的方法中使用。

这就引出作用域的概念。作用域可以简单地理解为变量的生存期或者作用范围，也就是变量从定义开始到什么时候消亡。

局部变量的作用域仅限于定义它的方法内。而成员变量的作用域在整个类内部都是可见的。
同时在相同的方法中，不能有同名的局部变量；在不同的方法中，可以有同名的局部变量。
成员变量和局部变量同名时，局部变量具有更高的优先级。

2.3 构造方法

在创建对象时，系统会自动调用类中的构造方法来完成。每个类都有构造方法，在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法。

创建一个对象的时候，至少调用一个构造方法。比如在新建一个对象 new Object()，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。构造方法的名称必须与类名相同，一个类可以定义多个构造方法。

构造方法的名称与类名相同，可以指定参数，且没有返回值。

public 构造方法名(参数列表) {
    // 初始化代码
}

例如：

public class People {
    // 无参构造方法
    public People() {
    
    }
    // 有一个参数的构造方法
    public People(int age) {
    
    }
}

更加具体的例子：

public class People {
    double height;
    int age;
    int sex;

    public People(double h, int a,int s) {
        height = h;
        age = a;
        sex = s;
    }
}

// 创建对象并初始化属性
People MangoGO = new People(175.5, 25, 0);

上面使用了 new + 构造方法 将类实例化成对象。

如果在定义类的时候没有写构造方法，系统会默认生成一个无参构造方法，这个构造方法什么也不会做。
当有指定的构造方法时，系统都不会再添加无参构造方法。
构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。

2.4 引用与对象实例

Object object = new Object();

变量 object 是一个引用变量，它指向了一个 Object 类型的对象实例。引用变量存储的是对象在内存中的地址，而不是对象本身。

Object object1 = new Object();
Object object2 = object1;
System.out.println(object1 == object2);

运行得到的结果为 true，说明 object1 和 object2 的内存地址相同 (== 会比较两个对象的内存地址是否相同），它们实际上是引用同一对象，如果改变 object1 对象内部的属性，那么 object2 的属性同样会改变，

2.5 static

2.5.1 静态成员

被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。

public class StaticTest{
    public static String string = "MangoGO";
    public static void main(String[] args){
        // 静态成员直接访问
        System.out.println(StaticTest.string);
        // 不加static的访问方式如下
        StaticTest staticTest = new StaticTest();
        System.out.println(staticTest.string);
        // 如果加static，以上两种方式均可        
    }
}

2.5.2 静态方法

被 static 修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用，由于不实例化也可以调用，所以不能有 this，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

2.6 final

final 关键字可以修饰类、方法、属性和变量

final 修饰类，则该类不允许被继承，为最终类
final 修饰方法，则该方法不允许被覆盖（重写）
final 修饰属性：则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）
final 修饰变量，则该变量的值只能赋一次值，即常量

public final static String MangoGO = "MangoGO";

2.7 权限修饰符

权限修饰符有 4 个，分别是 public、private、protected 和 default。

public：公共的，在任何地方都可以访问
private：私有的，只能在类的内部访问
protected：受保护的，只能在类的内部、子类和同一个包中访问
default：默认的，只能在类的内部和同一个包中访问

2.8 封装

封装是面向对象编程中一个重要的概念，封装是把对象的属性和行为（方法）封装在一起，对外隐藏内部的实现细节，只对外提供对外的接口，控制在程序中属性的读和修改的访问级别，使得对象的使用者不需要了解对象的内部实现细节，从而降低系统的耦合度。

我们在开汽车的时候，只用去关注如何开车，我们并不在意车子是如何实现的，这就是封装。

实现封装：

修改属性的可见性，私有属性使用 private 修饰，只能在类的内部访问，外部无法访问。
对每个值属性提供对外的公共方法访问方式：getter 和 setter 方法，通过 getter 和 setter 方法来获取和修改私有属性的值。
在getter 和 setter 方法中添加一些逻辑，比如对属性进行校验，对非法输入给予否定。

首先在类里要将属性前添加 private 修饰符。然后定义 getter 和 setter 方法。

public class People2 {
    private double height;
    public double getHeight() {
        return height;
    }
    
    public void setHeight(double newHeight) {
        height = newHeight;
    }
}

现在 main 函数里的对象不能直接调用属性了，可以通过 getter 和 setter 方法来获取和修改属性的值。

public class NewObject2 {
    public static void main(String[] args) {
        People MangoGO = new People2();
        MangoGO.setHeight(175.5);
        System.out.println(MangoGO.getHeight());
    }
}

!java NewObject2.java

175.5

2.9 this

this 关键字代表当前对象，使用 this.属性 操作当前对象的属性， this.方法() 操作当前对象的方法。

在类的内部，this 可以省略。

在类的外部，this 必须要写。

public void setAge(int age) {
    this.age = age;
}
public int getAge() {
    return age;
}

上面代码中 setAge 参数名和属性名相同，所以需要使用 this.age 来区分。

2.10 继承

继承可以看成是类与类之间的衍生关系。比如狗类是动物类，牧羊犬类又是狗类。于是我们可以说狗类继承了动物类，而牧羊犬类就继承了狗类。于是狗类就是动物类的子类（或派生类），动物类就是狗类的父类（或基类）。

父类更通用，子类更具体。

class 子类 extends 父类

例如我们定义了一个 Animal 类，再创建一个 Dog 类，我们需要它继承 Animal 类。

class Dog extends Animal {
    ···
}

public class Animal {
    public int legNum;

    public void bark() {
        System.out.println("动物叫！");
    }
}

public class Dog extends Animal {
}

public class ExtendsTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.legNum = 4;
        dog.bark();
    }
}

!java ExtendsTest.java

动物叫！

2.11 super

super 关键字代表父类，在子类内部使用。

访问父类的属性：super.属性
访问父类的方法：super.方法()
子类访问父类的构造方法，在子类的构造方法里最前面要加上 super()

2.12 方法重载与重写

2.12.1 方法重载

方法重载是同一个类中，方法的名称相同，但是参数列表不同，一般用于创建一组任务相似但是参数不同的方法。

public class OverloadTest {
    void f(int i) {
        System.out.println("i=" + i);
    }

    void f(float f) {
        System.out.println("f=" + f);
    }
    
    void f(String s) {
        System.out.println("s=" + s);
    }

    void f(String s1, String s2) {
        System.out.println("s1+s2=" + (s1 + s2));
    }

    void f(String s1, int i) {
        System.out.println("s=" + s + ", i=" + i));
    }

    public static void main(String[] args) {
        OverloadTest test = new OverloadTest();
        test.f(1);
        test.f(1.0f);
        test.f("MangoGO");
        test.f("MangoGO", "GO");
        test.f("MangoGO", 1);
    }
}

!java OverloadTest.java

i=1
f=1.0
s=MangoGO
s1+s2=MangoGOGO
s=MangoGO, i=1

2.12.2 方法重写

方法重写是子类继承父类的方法，但如果子类对父类的方法不满意，想在里面加入适合自己的一些操作时，就需要将方法进行重写。子类方法与父类方法名称相同，参数列表相同，返回值相同。子类在调用方法中，优先调用子类的方法。

比如 Animal 类中有 bark() 这个方法代表了动物叫，但是不同的动物有不同的叫法，比如狗是汪汪汪，猫是喵喵喵。

public class Animal {
    public void bark() {
        System.out.println("动物叫！");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("汪汪汪！");
    }
}

public class OverrideTest {
    public static void main(String[] args) {
        Animal animal = new Dog2();
        animal.bark();
    }
}

!java OverrideTest.java

汪汪汪！

2.13 多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态的实现原理是：父类引用指向子类对象，子类对象调用父类方法时，实际调用的是子类重写的方法。

2.13.1 多态的实现条件

继承、重写、向上转型。只有满足上述三个条件，才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

2.13.2 多态的实现方式

继承父类进行方法重写
抽象类和抽象方法
接口实现

2.13.3 向上转型

向上转型（upcasting）是指将子类对象赋值给父类引用。

Animal a = new Animal();  // a是父类的引用，指向的是本类的对象
Animal b = new Dog();  // b是父类的引用，指向的是子类的对象

在这里，可以认为由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。

但是，不能使用一个子类的引用去指向父类的对象，因为子类对象中可能会含有父类对象中所没有的属性和方法。

如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。

public class Dog3 extends Animal
{
    public void bark()
    {
        System.out.println("汪汪汪！");
    }
    public void dogType()
    {
        System.out.println("这是什么品种的狗？");
    }
}

public class UpcastingTest
{
    public void main(String[] args)
    {
        Animal a = new Animal();
        Animal b = new Dog3();
        Dog d = new Dog3();

        a.bark();
        b.bark();
        // b.dogType();
        // b.dogType()编译不通过
        d.bark();
        d.dogType();
    }
}

!java UpcastingTest.java

动物叫！
汪汪汪！
汪汪汪！
这是什么品种的狗？

由于 b 是父类的引用，指向子类的对象，因此不能获取子类的方法（dogType() 方法）, 同时当调用 bark() 方法时，由于子类重写了父类的 bark() 方法，所以调用子类中的 bark() 方法。

因此，向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写（方法名，参数都相同）。

2.13.4 抽象类

在定义类时，前面加上 abstract 关键字修饰的类叫抽象类。

抽象类中有抽象方法，这种方法是不完整的，仅有声明而没有方法体。抽象方法声明语法如下：

abstract void f();

用到抽象类的场景：

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。
从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

所以由上可知，抽象类是限制规定子类必须实现某些方法，但不关注实现细节。

抽象类的实现：

用 abstract 关键字修饰类。
用 abstract 关键字修饰方法，只用声明，不写方法体。
包含抽象方法的类就是抽象类。
抽象类中可以包含普通方法，也可以没有抽象方法。
抽象类不能直接创建对象，通常是定义引用变量指向子类对象。

// 抽象方法
public abstract class TelePhone {
    public abstract void call();
    public abstract void message();
}

// 子类
public class CellPhone extends TelePhone {
    @Override
    public void call() {
        System.out.println("打电话");
    }

    @Override
    public void message() {
        System.out.println("发短信");
    }

    public static void main(String[] args) {
        CellPhone cp = new CellPhone();
        cp.call();
        cp.message();
    }
}

!java CellPhone.java

打电话
发短信

2.13.5 接口

接口是抽象类的延伸，在 Java 中，接口是一个完全抽象的类，也就是说接口中只包含抽象方法，并且接口中的所有方法都是抽象方法。接口用于描述类所具有的功能，而不提供功能的实现，功能的实现需要写在实现接口的类中，并且该类必须实现接口中所有的未实现方法。

修饰符 interface 接口名 [extends 父接口名] {
    // 声明变量
    // 抽象方法
}

例如：

interface Animal2 {
    //int x;
    //编译错误,x需要初始化，因为是 static final 类型

    int y = 5;
    public void eat();
    public void travel();
}

Java 8 注意点：

接口不能实例化对象。
接口中的方法只能是抽象方法、default 方法、static 方法。
接口成员是 static final 类型。
接口支持多继承。

在 Java9 中，接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。

多继承实现：

修饰符 interface A extends 接口1, 接口2 {

}

修饰符 class A implements 接口1, 接口2 {

}

具体实现：

public class Cat implements Animal2 {

    public void eat() {
        System.out.println("Cat eats");
    }

    public void travel() {
        System.out.println("Cat travels");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.travel();
    }
}

!java Cat.java

Cat eats
Cat travels

2.14 内部类

内部类是定义在另一个类里面的类。包含内部类的类称为外部类。

内部类的主要作用是：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问。
内部类的方法可以直接访问外部类的所有数据，包括私有数据。
内部类所实现的功能使用外部类同样可以实现，只是使用内部类更加方便。
内部类允许继承多个非结构类型（后面讲解）。

内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量 / 方法名可以和外部类的相同。

2.14.1 成员内部类

// 外部类 
public class People {
    private String name = "MangoGO";
    
    // 内部类
    public class Student {
        String ID = "123456";

        public void stuInfo() {
            System.out.println("外部类name: " + name);
            System.out.println("内部类ID: " + ID);
        }
    }

    public static void main(String[] args) {
        People a = new People();  // 实例化外部类
        Student b = a.new Student();  // 使用外部类对象创建内部类对象
        // 或者为People.Student b = a.new People.Student();
        b.stuInfo();
    }
}

!java People3.java

外部类name: MangoGO
内部类ID: 123456

2.14.2 静态内部类

静态内部类通常被称为嵌套类。

// 外部类
public class People4 {
    private String name = "MangoGO";

    static String ID = "out123456";

    // 静态内部类
    public static class Student {
        String ID = "123456";

        public void stuInfo() {
            System.out.println("外部类name: " + (new People4().name));
            System.out.println("外部类ID: " + People4.ID);
            System.out.println("内部类ID: " + ID);
        }
    }

    public static void main(String[] args) {
        Student b = new Student();
        b.stuInfo();
    }
}

!java People4.java

外部类name: MangoGO
外部类ID: out123456
内部类ID: 123456

2.14.3 局部内部类

局部内部类是定义在方法内部或作用域中的类。

// 外部类
public class People5 {
    // 定义在外部类的方法中
    public void peopleInfo() {
        final String sex = "男";
        // 局部内部类
        class Student {
            String ID = "123456";

            public void stuInfo() {
                System.out.println("外部类方法中的sex: " + sex);
                System.out.println("内部类ID: " + ID);
            }
        }
        Student a = new Student();
        a.stuInfo();
    }

    // 定义在外部类的作用域中
    public void peopleInfo2(boolean b) {
        if (b) {
            final String sex = "男";
            // 局部内部类
            class Student {
                String ID = "123456";

                public void stuInfo() {
                    System.out.println("外部类方法中的sex: " + sex);
                    System.out.println("内部类ID: " + ID);
                }
            }
            Student a = new Student();

            a.stuInfo();
        }
    }

    public static void main(String[] args) {
        People5 b = new People5();
        System.out.println("定义在外部类的方法中---------------");
        b.peopleInfo();
        System.out.println("定义在外部类的作用域中---------------");
        b.peopleInfo2(true);
    }
}

!java People5.java

定义在外部类的方法中---------------
外部类方法中的sex: 男
内部类ID: 123456
定义在外部类的作用域中---------------
外部类方法中的sex: 男
内部类ID: 123456

2.14.4 匿名内部类

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

// 外部类
public class Outer {
    public Inner getInner(final String name, String city) {
        // 匿名内部类
        return new Inner() {
            private String nameStr = name;
            public String getName() {
                return nameStr;
            }
        };
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.getInner("Inner", "Beijing");
        System.out.println(inner.getName());
    }
}

interface Inner {
    String getName();
}

!java Outer.java

Inner

2.15 package

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

定义包语法：

package 包名
//注意：必须放在源程序的第一行，包名可用"."号隔开

例如：

//在定义文件夹的时候利用"/"来区分层次
//包中用"."来分层
package com.mangogo.java

如何在不同包中使用另一个包中的类？

使用 import 关键字。比如要导入包 com.mangogo 下 People 这个类，import com.mangogo.People;。同时如果 import com.mangogo.; 这是将包下的所有文件都导入进来，是通配符。

包的命名规范是全小写字母拼写。

参考代码

GitCode

系列文章专栏：
Java入门

1 基础部分 \

2 面向对象 \

3 常用类 \

持续更新中：\

MangoGO芒狗狗

关注

17
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java入门2: 面向对象

对象，万事万物皆为对象。面向对象，就是指从这个对象的整体出发，看它由哪些部件组成，可以做到哪些事情。比如一个人，他有名字、年龄、性别等属性，也有吃饭、睡觉、工作等行为。我们把这些属性和行为封装在一个对象中，就可以很方便地描述这个人。面向对象的思想，体现的是人所关注对象的信息聚集在了一个具体的物体上。人们就是通过对象的属性和行为来了解对象。类是对象的抽象，是对一类对象的描述。通过类可以创建出具有相同属性和行为的对象。比如，人类就是一个类，每个人都是这个类的一个实例。由此可以总结出类的定义：
复制链接

扫一扫