JAVA学习——Java中关于类的定义以及类的进阶知识（一）

目录

一、面向过程和面向对象

1.1 面向过程

1.2 面向对象

二、Java中的类

2.1 类的定义

2.2 对象

2.3 类定义的格式

2.3.1类的定义格式举例

2.3.2 类的调用

三、Java类中关键字

3.1 private

3.2 this

3.3 static

3.4 final

四、构造方法

4.1 定义

五、Java标准类和隐匿对象

5.1 定义一个标准类

5.2 隐匿对象

一、面向过程和面向对象

本文是用来记录自己的学习过程

1.1 面向过程

当需要实现一个功能的时候，每一个具体的步骤都需要亲力亲为，详细处理每一个细节。

1.2 面向对象

当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的类，来调用类中的方法。

小例子：创建一个数组[10,20,30,40,50]，要求打印格式为[10,20,30,40,50]

public class Demo1 {

    public static void main(String[] args) {

        int[] array = {10,20,30,40,50};

        //要求打印格式[10,20,30,40,50]

        //面向过程：

        System.out.print("[");

        for (int i = 0; i < array.length; i++) {

            if (i == array.length - 1 ){

                System.out.println(array[i] + "]");

            }else {

                System.out.print(array[i] + " ,");

            }

        }

        System.out.println("=============================");



        // 面向对象

        // 使用JDK封装好的Arrays类，然后使用类中的toString方法，直接就能把数组变成想要的格式的字符串。

        System.out.println(Arrays.toString(array));

    }

}
           

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者，面向对象的语言中，包含了三大基本特征，即封装、继承和多态。Java是一种面向对象的语言。

二、Java中的类

2.1 类的定义

类：是一组相关属性和行为的集合。可以看成是一类事务的模板，使用事务的属性特征和行为特征来描述该类事务，是抽象的。

属性：该事务的状态信息（一组成员变量）

行为：该事务能够做的事情，即类中的函数或者方法（）

2.2 对象

对象：是一类事务的具体体现。对象是类的实例（不是女朋友），所以具备该类事务的属性和行为。类是抽象的，对象是具体的。

2.3 类定义的格式

public class ClassName{

// 成员变量

// 成员方法

}
           

1. 定义类：就是定义类的成员，包括成员变量和成员方法
2. 成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
3. 成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象
4. 注意事项：

成员变量是直接定义在类当中的，在方法外边。成员方法不要写在static关键字。

2.3.1类的定义格式举例

/*

成员变量（属性）：

    String name; //姓名

    int age; // 年龄



成员方法（行为）：

    public void eat(); // 吃饭

    public void sleep(); // 睡觉

    public void study(); // 学习

*/

public class Student {

    String name;

    int age;



    public void eat(){

        System.out.println("吃饭");

    }

    public void sleep(){

        System.out.println("睡觉");

    }

    public void study(){

        System.out.println("学习");

    }

}
           

2.3.2 类的调用

Student类接上文，文件结构如下图所示

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

1. 导包：也就是指出需要使用的类，在什么位置。

   import 包名称.类名称；

   import com.Day6Demo.Student

   对于和当前类属于同一个包的情况下，可以省略导包语句不写。

2.  创建格式：

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

   Student stu = new Student()

3. 使用，分为两种情况：

   使用成员变量：对象名.成员变量名

   使用成员方法：对象名.成员方法名(参数)

新建一个java类（StudentClass02）调用Student类，代码如下：

public class StudentClass02 {
    public static void main(String[] args) {
        // 1. 导包
        // 对于和当前类属于同一个包的情况下，可以省略导包语句不写。

        // 2. 创建格式：
        //  类名称 对象名 = new 类名称();
        Student stu = new Student();
        // 3. 使用
        // 使用成员变量：对象名.成员变量名
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println("=================");
        //使用成员方法：对象名.成员方法名(参数)
        stu.eat();
        stu.sleep();
        stu.study();
        System.out.println("=================");
        //给成员变量重新赋值
        stu.name = "周杰伦";
        stu.age = 18;
        System.out.println(stu.name);
        System.out.println(stu.age);

    }
}
           

三、Java类中关键字

3.1 private

面向对象有三大特征：封装、继承和多态。

• 封装：就是将类中一些细节信息隐藏下来，对于外界不可见，只对外公开接口。
• 继承：继承是面向对象的基本特征之一，继承机制允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
• 多态：同一个行为具有多个不同表现形式或形态的能力。是指一个类实例（对象）的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

封装性在Java当中的体现：

1. 方法就是一种封装
2. 关键字private也是一种封装（私有化，类似于）

以Student类为例，想要对Student的成员变量进行保护，需要使用private方法，另外，经过封装后的类成员变量不能直接使用，需要定义Setter和Getter方法（必须叫setXxx或者getXxx命名规则）。代码如下：

public class Person {
    String name;
    private int age;

    public void show() {
        System.out.println("姓名：" + name + "年龄：" + age);
    }

    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num){
        if (num < 150 && num>0){
            age = num;
        }else {
            System.out.println("格式输入不对！");
        }
    }

    // 这个成员方法，专门用于获取age的数据
    public int getAge() {
        return age;
    }
}
           

使用private封装后，想要修改或者调用Student的成员变量，需要使用方法为：

public class Demo1Student {

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(12);
        student.setMale(true);

        System.out.println("姓名："+student.getName());
        System.out.println("年龄："+student.getAge());
    }
}
           

3.2 this

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。如果我们就需要这个局部变量名称，我就不改名，这个时候，需要对成员变量修改格式：this.成员变量this就相当于这个类，比如说我在Student类中使用this，那么this就是Student，this.成员变量就等于Student.成员变量（通过谁调用的方法，谁就是this，有点类似于python中的self）

3.3 static

详细用法请移步Java中static关键字的解析

3.4 final

final 关键字代表最终的、不可改变的。一旦使用final修饰，那么被修饰的就不能在进行任何改变。“一次赋值，终生不变”

常见的四种用法：

1. 可以用来修饰一个类；

当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
    // ...
}
含义：当前的这个类不能有任何的子类（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子）
           

2. 可以用来修饰一个方法；

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表){
    // 方法体
}

注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为互相矛盾。
           

3. 还可以用来修饰一个局部变量；

// 对于基本类型来说，不可变说的是变量当中的数据不能改变
// 对于引用类型来说，不可变说的是变量当中的地址值不能改变
           

final Student stu3 = new Student ("王五");
// 错误写法！final的引用变量类型，其中的地址不可改变
 //stu3 = new Student ("王祖贤");

System.out.println (stu3.getName ());//王祖贤
stu3.setName ("袁咏仪");
System.out.println (stu3.getName ());//袁咏仪
           

4. 还可以用来修饰一个成员变量。

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样不能修改。

1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2. 对于final修饰的成员变量，要么直接赋值，要么通过构造方法赋值，二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
           

四、构造方法

4.1 定义

1. 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，

其实就是再调用构造方法。(类似python中的__init__)

2. 格式：

    public  类名称（参数类型 参数名称）{

        方法体

    }

3. 注意事项：

• 构造方法的名称必须和所在的类名称完全一样
• 构造方法不要写返回值类型，连void都不写
• 构造方法不能return一个具体的返回值
• 如果没有写构造方法，那么编译器会默认给我们生成一个构造方法，没有参数、方法体什么事情都不做。一旦写了至少一个构造方法，那么编译器就不会在默认生成构造方法
• 构造方法也可以进行重载（方法名称相同，参数不同）。

public class Student {

    String name;
    int age;

    public Student() {
        System.out.println("无参数构造方法！");
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("全参数构造方法！");
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }
}
           

调用代码如下：

public class Demo1Student {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student("张三", 20);

        System.out.println("姓名" + student1.getName() + "," + "年龄" + student1.getAge());
        System.out.println("=================================");
        System.out.println("姓名" + student2.getName() + "," + "年龄" + student2.getAge());

        System.out.println("=================================");
        student1.setName("王老六");
        student1.setAge(98);
        System.out.println("姓名" + student1.getName() + "," + "年龄" + student1.getAge());

        System.out.println("=================================");
        student2.setName("周杰伦");
        student2.setAge(40);
        System.out.println("姓名" + student2.getName() + "," + "年龄" + student2.getAge());

    }
}
           

五、Java标准类和隐匿对象

5.1 定义一个标准类

一个标准的类通常要拥有下面四个组成部分：

1、所有的成员变量都要使用private关键字修饰

2、为每一个成员变量编写一对Getter/Setter方法

3、编写一个无参数的构造方法

4、编写一个全参数的构造方法

这样标准的类也叫做Java Bean（Java豆）

代码为：

public class Student {

    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

           

5.2 隐匿对象

创建对象的标准格式：

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

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。

new 类名称()

注意事项：匿名对象只能使用唯一一次，下次再用不得不再创建一个新对象。

使用建议：如果确定有一个对象只需要使用一次，就可以使用匿名对象，因为Java是面向对象的，所以使用隐匿对象，可以节省不必要的内存空间。

代码：

import java.util.Scanner;

public class Demo2Anonymous {

    public static void main(String[] args) {
        // 普通使用方式
        //Scanner sc = new Scanner(System.in);
        //int num = sc.nextInt();
        //System.out.println("输入的数字是："+num);

        //匿名对象的方式
        //int num = new Scanner(System.in).nextInt();
        //System.out.println("输入的数字是：" + num);

        //使用一般方法写入参数
        //Scanner sc = new Scanner(System.in);
        //methodParam(sc);

        // 使用匿名对象来进行传参
        //methodParam(new Scanner(System.in));

        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("输入的数字是：" + num);

    }
    public static void methodParam(Scanner sc){
        int num = sc.nextInt();
        System.out.println("输入的数字是：" + num);
    }

    public static Scanner methodReturn(){
        return new Scanner(System.in);
    }
}

           

六、Java中面向对象的三大特征

传送门：JAVA学习——Java中面向对象的三大特征

七、Java中的内部类

传送门：JAVA学习——Java中的内部类