Java中的面向对象（类、方法、关键字）

Smiling Mr. Rui

已于 2024-05-07 15:17:04 修改

阅读量922

点赞数 14

分类专栏：网络安全文章标签： java 开发语言

于 2024-05-05 17:46:35 首次发布

本文链接：https://blog.csdn.net/AXDRXS/article/details/138451146

版权

网络安全专栏收录该内容

31 篇文章 0 订阅

订阅专栏

前言：

所谓面向对象它是针对于面向过程来说的，面向过程是在意执行的流程。而面向对象在意的功能。将一系列的过程封装到一个容器中，我们通过操作这个容器即以对象的方式来进行操作就是面向对象。在面向对象中，会涉及到类和对象的概念。类是一类事物的总称，它是看不见摸不着的。如：空气、人。它们都看不见，也摸不着，但是又真实存在。对象是看得见摸得着的，它是类的一个具体的实例。一个类可以创建多个实例对象。

一、类

1.1 如何创建类

创建类分为以下三步：

第一步：给类取个名称
第二步：给类指定属性（类的特征）
第三步：给类指定行为（动作，也叫方法）

示例：我们定义一个人的类，它有身高、体重、性别、年龄等；同时它也具有吃、跑、走等行为。

/**
 * 示例：我们定义一个人的类，它有身高、体重、性别、年龄等；同时它也具有吃、跑、走等行为。
 *
 * 类的名称叫：Person，它的定义是首字母大小，其他字母小写。如果有多个单词，每个单词的首字母大写如：UserName。类是需要被 class 关键字修改的
 *
 * 属性的定义格式：
 * 属性的类型 属性名称;
 *
 * 方法的定义格式：
 * 访问的访问修饰符 方法的返回值类型 方法名称(参数列表) {
 *     方法体;
 *     [return 返回值]
 * }
 *
 * 访问的访问修饰符：在 Java 中访问修饰符有以下几种：
 * 1. public，它表示是公共的，所有的类都可以访问，包括互联网。
 * 2. protected，它表示是受保护的，只当前类或其子类才可以访问
 * 3. default，它表示是默认的，只当前类及当前类所在包中的类可以访问，default 不写
 * 4. private，它表示是私有的，只有当前类可以使用
 *
 * void 关键字：它表示方法没有返回值。如果一个方法的返回值是 void ，那么这个方法就没有返回值，但是我们可以在方法的最后书写 return 语句，但是 return 关键字不能有内容。
 * 如果方法的返回值类型不是 void ， 而是其它类型，则方法中必须要有 return 语句，而 return 返回的值的类型必须是方法要求返回的类型。
 *
 * 方法名称的定义方式：单词小写，如果由多个单词组成，则第一个单词的首字母小写，其余单词的首字母大写，如：userName()，在方法名称后面必须要有一对小圆括号。
 * 方法体就在一对大括号之间。
 *
 * 方法还可以传参数，它的格式为：
 * 参数类型 参数名称
 *
 *
 */
public class Person {
    float height; // 身高
    float weight; // 体重
    String gender; // 性别
    int age; // 年龄

    public void speak() {
        System.out.println("身高: " + height + ", 体重：" + weight + ", 性别: " + gender + ", 年龄：" + age);
        //return null; // 报错
        return;
    }

    public int getAge() {
        return age;
    }

    // 带有参数的方法，如果参数有多个，则使用逗号进行分隔
    public void say(String str) {
        System.out.println(str);
    }
}

1.2 如何使用类

类定义好后，目的是为了使用这个类。而要使用这个类，就必须通过 new 关键字来进行实例化。这个过程叫创建对象。

使用类的格式为：

类名称 引用名称 = new 类名称();

示例：我们创建Person对象

/**
 * 代码解析：
 * 1. Person person = new Person(); 表示创建一个名称叫 person 的对象，它的类型是 Person。要使用对象之前必须创建对象
 * 2. 通过点（.）操作来给创建好的对象赋值以及调用对象的方法。
 */
public class PersonDemo {
    public static void main(String[] args) {
        // 1. 创建对象
        Person person = new Person();
        // 2. 给对象中的属性赋值
        person.height = 185.1f;
        person.weight = 125.5f;
        person.gender = "男";
        person.age = 18;

        person.speak();

        //System.out.println(person);
    }
}

补充：在类中定义的属性与变量的区别：

定义的位置不同：属性是定义在类中，而变量是定义在方法中的。
在内存中的位置不同：属性是在堆中的，而变量是在栈中。
声明的周期不同：属性是在对象创建是放到堆中的且会随着对象的消失而消失，而变量是在栈中且方法执行后就消失。
初始化不同：属性是在对象创建时初始化，而变量是在定义时就初始化。

二、方法

2.1 构造方法

在一个类中，如果方法的名称和类名称相同，并且这个方法没有返回值类型，则该方法就叫构造方法（也叫构造函数，还叫构造器）。

class Human {
    String name;
    private int age;

    public Human(){

    }
    public Human(String n, int a) {
        name = n;
        age = a;
    }
    // 它是一个普通方法，不是构造器
    public void human() {

    }
}

2.1.1 构造器的作用

就是给对象中的属性进行初始化

为了在创建对象的同时就给这个对象进行赋值，如果没有构造器，我们需要先把这个对象创建好后，再给对象中的属性进行赋值。虽然在没有定义构造器时，系统也会给我们一个默认的无参数的构造器，但这个构造器只能根据类中属性的类型来进行默认值的赋予，而达不到我们指定值赋予。

2.1.2 如何编写构造器

只需要在类中声明方法的名称与类名称相同，并且这个方法没有返回值类型即可，构造器可重载。

class Human {
    String name;
    private int age;

    public Human(){

    }
    public Human(String n, int a) {
        name = n;
        age = a;
    }
}

注意：在创建对象时已经使用到了构造器，创建对象是使用构造器完成的。

2.2 默认方法

在JDK1.8中的定义了默认方法，这个方法必须使用 default 关键字修饰，同时这个方法必须要实现。

// 默认方法
interface IntA {
    default void sayHello() {
        System.out.println("Hello");
    }
    default String eat(String s) {
        return s;
    }
}

public class InterfaceDemo2 implements IntA {
    @Override
    public void sayHello() {
        System.out.println("hi");
    }

    public static void main(String[] args) {
        InterfaceDemo2 id = new InterfaceDemo2();
        System.out.println(id.eat("吃火锅"));

        id.sayHello();
    }
}

子类可以直接实例接口中定义默认方法而无须重写，当然我们也可以根据自己的需要来重写接口中的默认方法。

2.3 静态方法

在 JDK1.8 中还定义静态方法，它是使用 static 关键字来修饰的，它也必须是实现的方法。

// 静态方法

interface IfaceA {
   static void print(String str) {
       System.out.println(str);
   }
   static int getNum(int n) {
       return n;
   }
}

public class InterfaceDemo3 implements IfaceA {
    public static void main(String[] args) {
        InterfaceDemo3 id = new InterfaceDemo3();
        //id.getNum(); // 报
        System.out.println(IfaceA.getNum(10));
        IfaceA.print("大家上午好！");
    }
}

在接口中定义的静态方法，子类是不能使用的，它只能是接口自己使用。

补充：抽象方法我们放到后面单独拿出来和接口一起进行学习。

三、关键字

3.1 static关键字

如果希望类中的方法能够通过 类名.方法名() 的方式来进行访问，那么就需要使用 static 关键字来修饰这个方法。这个关键字必须放在方法返回值类型之前，访问修饰符之后（高版本中这名不成立）。

    static String name;
    private static int age;

	public static int  getAge() {
        return age;
    }

3.1.1 static关键字的使用要求

1，static关键字可以修改方法，也可以修改属性，但是不能修改变量

class Human {
    static String name;
    public static int  getAge() {
        //static int x = 5;  // 报错，不能修改变量
        return age;
    }
}

2，static关键字修改的方法可以通过 类名.方法名() 来访问，修饰的属性可以通过 类名.属性名 来访问

class Human {
    static String name;
    public static int  getAge() {
        //static int x = 5;
        return age;
    }
}
public class HumanTest {
    public static void main(String[] args) {
        System.out.println(Human.getAge() + ", " + Human.name);
    }
}

3，被static修改的方法叫类方法，被statis修饰的属性叫类属性，因此可以通过 类名.的方式来使用

4，在static修饰的方法中不能使用非静态变量

class Human {
    static String name;
    private static int age;
    String gender;
    public static int  getAge() {
        gender = "男"; // 报错，静态方法中不能使用非静态的属性
        return age;
    }
}

不能使用的原因：因为被 static 修饰的方法和属性它们的生命周期与类的生命周期相同。而非静态的方法和属性的生命周期是在创建这个对象时才有的。换句话说：被 static 修饰的成员的生命周期要比非静态的成员的生命周期长。

3.2 super关键字

这个关键字是用于子类调用父类中的属性或方法的。

如果它是调用父类中的构造器方法，那么它必须是子类构造方法的第一句。

class Animal {
    private String name;
    private int age;

    public Animal() {

    }

    public Animal(String n, int a) {
        name = n;
        age = a;
    }
    public void show() {
        System.out.println(name + " " + age);
    }
}

class Dog extends Animal {
    private String color;
    public Dog() {}
    public Dog(String n, int a, String c) {
        super(n, a); // 调用父类的构造方法
        color = c;
    }
    public void show() {
        System.out.println(color);
        super.show();
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Dog d = new Dog("沙皮狗", 2, "黄色");
        d.show();
    }
}

3.3 this关键字

1）这个关键字可以调用本类中的构造方法，如果是调用本类中的构造方法，那么它也必须是第一行。

class Cat {
    public String name;
    public int age;
    public String color;
    public Cat() {
        System.out.println("无参构造器被调用了。。。。。");
    }
    public Cat(String n) {
        this();
        System.out.println("这是有一个name的构造器被调用了......");
    }
    public Cat(String n, int a) {
        this(n);
        System.out.println("调用了name和age的构造器.....");
    }
    public Cat(String n, int a, String c) {
        this(n, a);
        System.out.println("这是调用了name、age以及color的构造器......");
    }

    public static void main(String[] args) {
        Cat cat = new Cat("小花", 2, "白色");
    }
}

注意：在调用本类构造器时，必须要有一个出口。

2）可以调用对象中的属性和方法

    public void show() {

    }
    public void say() {
        this.show();
    }
//this指向被创建的对象引用

3.4 final关键字

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

如果final修饰的是类，那么这个类就不能有子类，也就是说它不能被继承。

如果final修饰的是属性，那么这个属性就是常量，通常会和 static 关键字一起使用。

如果final修饰的是方法，那么这个方法就不能被重写。

final class Father {
    static final String name;
    /*Father(String name) {
        this.name = name;
    }*/
    static {
        name = "";
    }

    public final void sayHi() {
        System.out.println(name);
    }
}
class Son extends Father {
    int age;
    public Son() {

    }
    public Son(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void sayHi() {
        super.sayHi();
        System.out.println(age);
    }
}

public class FinalDemo {
    public static void main(String[] args) {
        Son son = new Son("小华", 18);
        son.sayHi();
    }
}