Java码农人生开启手册——类和对象

小刘要进步

已于 2024-09-05 16:38:23 修改

阅读量932

点赞数 17

文章标签： java 开发语言

于 2024-08-01 16:46:22 首次发布

本文链接：https://blog.csdn.net/2301_76907962/article/details/140712413

版权

一、类的定义和使用

类是用来对一个实体（对象）来进行描述的。

注意：

类名采用大驼峰定义
可以理解为一个模版

class Person {
    //属性
    public String name;
    public int age;

    //行为  方法
    public void sleep() {}
}

二、类的实例化

定义了一个类，就相当于在计算机中定义了一个新的类型，用类的类型创建对象的过程，称为类的实例化。

注意：

new关键字用于创建一个对象的实例；
使用 . 来访问对象中的属性和方法；
同一个类可以创建多个实例。

说明：

类只是一个模型，用来描述一个实体，限定实体有哪些成员。
类是一种自定义的类型，可以用来定义变量。
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
类相当于设计图纸，只设计出需要什么东西；类的实例化就像使用这个图纸建造出来的房子，实际存储数据，占用物理空间。

三、this引用

this引用指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中，所有成员变量的操作都是通过该引用去访问的。

this引用的特性：

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型。
this只能在成员方法中使用。
在成员方法中，this只能引用当前对象，不能引用其他对象。

this 是 “成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法， this 负责来接收。

public void setData (Data this, int y, int m, int d) {
    this.year = y;
    this.month = m;
    this.day = d;
}
//参数列表中的 Data this 是隐藏的，谁调用的方法this就是谁。

public void setData (int year, int month, int day) {
    year = year;
    month = month;
    day = day;
}
//因为局部变量优先，所以是形参自己给形参自己赋值，因此在编程的过程中要习惯使用this。

四、对象的创造和初始化

1、构造方法

名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

注意：

构造方法没有返回值类型，设置为void也不行；
一般情况下用public修饰；
构造方法的作用就是对对象的成员进行初始化，并不负责给对象开辟空间。

特性：

名字必须与类名相同。
没有返回值类型，设置为void也不行。
创建对象时由编译器自动调用，并且在整个对象的生命周期内只调用一次。（相当于人的一生只出生一次）
构造方法可以重载。
如果用户没有显式定义，编译器会生成一份默认的无参构造方法。一旦用户定义，编译器则不会生成。
在构造方法中，可以使用this调用其他的构造方法来简化代码。
this（……）必须是构造方法中的第一条语句。
不能形成闭环。
大多数情况下使用public修饰，特殊场景下会被private修饰（单例模式时会遇到）。

2、默认初始化

new关键字的作用：

检测对象对应的类是否加载了，如果没有加载则加载。
为对象分配内存空间。
处理并发安全问题。（比如多个线程同时申请对象，JVM要保证给对象分配的空间不冲突）
初始化所分配的空间。即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值（一.1）。
设置对象头信息。（对象内存模型部分介绍）
调用构造方法给对象各个成员赋值。

3、就地初始化

在声明成员变量时，就直接给出初始值。（注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。）

五、封装

面向对象三大特性（封装、继承、多态）之一。简单来说，封装就是套壳屏蔽细节。

1、概念

将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。从语法上来说，就是private修饰的成员变量和成员方法，只能在当前类中使用。

2、访问限定符

在Java中，主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用。

注意：

protected主要用于继承；
什么都不写时默认的权限为default；
访问权限除了可以限定类中成员的可见性以外，还可以控制类的可见性；
一般情况下成员变量设置为private，成员方法设置为public。

3、包

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

3.1导入包中的类

使用 import 语句导入包。可以使用import static导入包中静态的方法和字段。

注意：import 和 C++ 的 #include 差别很大。C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。import 只是为了写代码的时候更方便。import 更类似于 C++ 的 namespace 和 using。

3.2自定义包

基本规则：

在文件的最上方加上一个 package 语句指定该代码在哪个包中。
包名需要尽量指定成唯一的名字。

包名要和代码路径相匹配。例如创建 com.bit.demo1 的包，那么会存在一个对应的路径 com/bit/demo1 来存储代码。

如果一个类没有 package 语句，则该类被放到一个默认包中。

3.3常见的包

java.lang: 系统常用基础类 (String 、 Object), 此包从 JDK1.1 后自动导入

java.lang.reflect:java 反射编程包

java.net: 进行网络编程开发包

java.sql: 进行数据库开发的支持包

java.util: 是 java 提供的工具程序包。 ( 集合类等 ) 非常重要

java.io:I/O 编程开发包

六、static成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

1、static修饰成员变量（静态成员变量）

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

特性：

不属于某个具体的对象，是类的属性，所有对象共享的，不储存在某个对象的空间中。
既可以通过对象访问，又可以通过类名访问，但一般推荐通过类名访问。
类变量储存在方法区中。
生命周期伴随类的一生。（随类的加载而创造，随类的卸载而销毁）
static只能修饰成员变量，不能修饰局部变量。

2、static修饰成员方法（静态成员方法）

static修饰的成员方法，称为静态成员方法，是类的方法，不是某个对象特有的。静态成员一般通过静态方法访问。

特征：

不属于具体的对象，是类方法。
直接通过类名就可以调用，不依赖于对象。
可以通过对象调用，但更推荐通过类名调用。
不能在静态方法中访问任何非静态成员变量。
静态方法中不能调用任何非静态方法，因为非静态方法中有this参数，在静态方法中调用时候无法传递this引用。
静态方法无法重写，不能实现多态。

3、static成员变量初始化

注意：静态成员变量一般不会放在构造方法中初始化，构造方法中初始化的是与对象有关的实例属性。

3.1就地初始化

在定义时直接给出初始值。

3.2静态代码块初始化

什么是静态代码块？继续往后看……

七、代码块

使用 {} 定义的一段代码称为代码块。

代码块执行顺序：

静态代码块先执行
然后执行构造代码块
再执行对应的构造方法
静态的只执行一次

1、普通代码块

定义在方法中的代码块。不常用。

public class Main{
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10 ;
            System.out.println("x1 = " +x);
        }
        int x = 100 ;
        System.out.println("x2 = " +x);
        }
    }

// 执行结果
x1 = 10
x2 = 100

2、构造代码块

定义在类中的代码块（不加修饰符），也叫 实例代码块。一般用于初始化实例成员变量。

public class Student{
    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;
    public Student() {
        System.out.println("I am Student init()!");
    }
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}

// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

注意：

构造代码块（实例代码块）只有在创建对象时才会执行。

3、静态代码块

使用static定义的代码块。一般用于初始化静态成员变量。

public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }

    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

    public Student(){
    System.out.println("I am Student init()!");
    }

    public static void main(String[] args) {
    Student s1 = new Student();
    Student s2 = new Student();
    }
}

4、同步代码块

多线程部分谈……

注意：

静态代码块不管生成多少个对象，其只会执行一次。
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的。
如果一个类中有多个静态代码块，在编译代码时，编译器会按照定义的顺序依次执行（合并）。

八、内部类

1、成员内部类

在外部类中，内部类定义位置与外部类成员所处位置相同，因此称为成员内部类。

1.1 实例内部类

未被static修饰的成员内部类。

注意：
外部类中的任何成员都可以在实例内部类方法中直接访问；
实例内部类所处位置与与外部类成员位置相同，因此也受public、private等访问限定符的约束；

在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须用外部类名称 .this. 同名成员来访问；
实例内部类对象必须在先有外部类对象前提下才能创建；
// 创建实例内部类对象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();

// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
实例内部类的非静态方法中包含了一个指向外部类对象的引用；

外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。