开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Java中的类与对象 -> 正文阅读

[Java知识库]Java中的类与对象

什么是类？什么是对象？

在了解什么是类，什么是对象之前，首先了解两个概念，即面向过程与面向对象。

面向过程

如“用洗衣机洗衣服”这个事情，人需要打开洗衣机盖，把衣服放进洗衣机，再加上洗衣粉，打开开关等等多个过程才可完成。

面向对象

总共有4个对象：人，衣服，洗衣粉，洗衣机。整个过程是通过这四个对象交互完成，人不需要了解洗衣服的过程，仅需要知道这四个对象即可。

总的来说，需要3个过程

找对象（由类而来）
创建对象
使用对象

简单创建一个类

class Person{

}

我们简单创建一个类，类名是Person

类里包含属性与方法。

属性，又叫字段，也叫成员变量

class Person{
    public String name;
    public int age;
}

其中，可以定义变量，如整型，字符串等。（注意，类里不建议对变量赋值）

成员方法，可以理解为行为

class Person{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
}

其中，eat方法就是类里的方法（这里不用static）。

这样我们就有了一个类。

创建对象

有了类，就可以创建对象了，可以使用new关键字来创建对象，这个过程称为实例化。

public static void main(String[] args){
    Person person = new Person();
}

这样就完成了对象的实例化。

Person person = new Person();

int a = 10;

其中Person是类，person相当于变量名a，new Person就是对象的实例化。

C语言是面向过程的，关注的是过程，分析求解问题的步骤，通过函数调用逐步解决问题。

Java是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

注意：一个类可以实例化多个对象，如：

public static void main(String[] args){
    Person person1 = new Person();
    Person person2 = new Person();
    Person person3 = new Person();    
    Person person4 = new Person();
}

这样就解释了为什么不建议在类里对变量赋值，若赋值，比如String name = "Kevin Durant"，那么在person1，person2等中，都会使name的值为"Kevin Durant"。

如何访问类里的成员与方法

可以通过对象的引用来访问

public static void main(String[] args){
    Person person = new Person();
    person.name = "Kevin Durant";
}

这样就对name进行了赋值。这里是指普通的成员变量进行访问。（还有静态的成员变量，后面再说）。

我们来看如下代码

class Person{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
}

public class TestDom {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
        person1.age = 10;
        System.out.println(person1.age);
        System.out.println(person2.name);
    }
}

运行结果如下

即每个对象都有一个对应成员变量

方法的访问

通过引用调用方法

class Person{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
}

public class TestDom {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Kevin Durant";
        person.eat();
    }
}

这也仅仅适用于普通的成员方法，对于静态的成员方法，后续再说。

类的成员

字段，属性，变量（普通成员变量，静态成员变量）

class Person{
    public int age;
    public static int count;
}

其中，age是普通成员变量，count是静态的成员变量

对于静态成员变量的访问，与普通成员变量类似。如：

public static void main(String[] args) {
        Person person1 = new Person();
        person1.count++;
        System.out.println(person1.count);
        Person person2 = new Person();
        person2.count++;
        System.out.println(person2.count);

    }

运行结果：

?发现与上面的age不同，count的值会自增。说明count是一个。因此静态成员变量也叫类变量。

所以对于静态的变量访问常用类名直接访问。以上代码可以改为：

public static void main(String[] args) {
        Person.count++;
        System.out.println(Person.count);
        Person.count++;
        System.out.println(Person.count);
    }

静态变量不依赖于对象，静态变量属于类

静态的成员方法

也叫静态方法，或类方法，通过类名直接访问。如

class Person{
    public static void sleep(){
        System.out.println("我爱睡觉");
    }

}

public class TestDom {
    public static void main(String[] args) {
        Person.sleep();
    }
}

运行如下

对于main函数，是不是静态的，都可以，这取决于JVM

null空指针

Person person = null;

这段代码表明person不指向任何对象

Person person = new Person();

Person pppperson = person;

这段代码表明，pppperson这个引用指向perosn这个引用所指向的对象

Person perosn = new Person();

person = new Person();

person = new Person();

person = new Person();

person = new Person();

person只能指向最后一次所指的对象

final修饰

class Person{
    public final int age = 10;
    public static final int count = 99;
}

对于final所修饰的变量，不影响其访问。

private封装

class Person{
    private String name;
}

此时，name变量只能在类里使用

此时需要在类里写下如下代码

class Person{
    private String name;
    public void setName(String myName){
        name =myName;
    }
    public String getName(){
        return name;
    }
}
public class TestDom {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Kevin Durant");
        System.out.println(person.getName());
 
}

运行结果如下

这样，你的写的类的代码就有很好的隐私性，提供getName()与setName()，为别人使用你的类的代码。这样你的代码更安全。

当private定义的变量越来越多时

    private String name;
    private int age;
    private double f;

可以通过快捷键来实现（鼠标右键，再单击Generate）

在选择Getter and Setter

全部选择

之后会自动生成

class Person{
    private String name;
    private int age;
    private double f;

    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;
    }

    public double getF() {
        return f;
    }

    public void setF(double f) {
        this.f = f;
    }
}

注意

private 不光能修饰字段也可以修饰方法
通常情况下，我们会把字段设为private属性，但方法是否要设为public，应根据情况而定

构造方法

构造方法：方法名与类名相同，且构造方法较为特殊，它无返回值

如：

class Person{
    public Person(){
        System.out.println("Person():是一个构造方法");
    }
}
public class MAIN {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

类中的：public Person(){
? ? ? ? ? ? ? ? ? System.out.println("Person():是一个构造方法");
? ? ? ? ? ? ? ?}

就是构造方法。

而main函数中的Person person = new Person();实际上就调用了构造函数Person()

那为什么之前的代码没有写构造函数但也可以正常运行呢？是因为在没有写构造函数时，编译器会默认生成一个不带参数的构造方法。

注意：一个类都有一个构造方法，在没有写构造方法时，编译器会默认生成一个不带参数的构造方法。

以上例子是不带参数的构造方法，下面看一个带参数的构造方法

class Person{
    public Person(){
        System.out.println("Person():是一个构造方法");
    }

    public Person(int a){
        System.out.println("参数大小是"+a);
    }


}
public class MAIN {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person(15);
    }
}

也很简单，仅仅是在Person()函数中写上参数即可。

运行结果

当然也可以写多个参数的构造方法，如

class Person{
    public Person(){
        System.out.println("Person():是一个构造方法");
    }

    public Person(int a){
        System.out.println("参数大小是"+a);
    }

    public Person(int a,double b){
        System.out.println(a+" 这是多个参数的构造方法 "+b);
    }
}
public class MAIN {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person(15);
        Person person3 = new Person(5,5.0);
    }
}

?运行结果：

在实例化多个对象时，会调用合适的构造方法

总结：

如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致

this关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法。

三种使用方法：

调用当前对象的属性
调用当前对象的方法
调用当前对象的其他构造方法（this()只能放在第一行，且只能存在于构造函数中）

代码块

使用 {} 定义的一段代码.

根据代码块定义的位置以及关键字，又可分为以下几种：

静态代码块

实例代码块

class Person{
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    Person(){
        System.out.println("构造方法");
    }

}
public class MAIN{
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果：

?可以发现，静态代码块先执行，其次是实例代码块，最后是构造方法

在{}内是实例代码块，static修饰的{}是静态代码块

实例多个对象，写下如下代码：

class Person{
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    Person(){
        System.out.println("构造方法");
    }

}
public class MAIN{
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("------------------");
        Person person2 = new Person();
    }
}

运行结果：

可以发现，静态代码块只执行一次，其实，静态代码块在类的加载时就执行了

匿名对象

匿名对象是一次性的

如：

class Person{
    public void eat(){
        System.out.println("我爱吃饭");
    }
}
public class MAIN{
    public static void main(String[] args) {
        new Person().eat();
    }
}

其中，new Person().eat()；就是匿名对象调用方法的代码语句。可以看出来，匿名对象是一次性的。