Java中的类与对象

Posted 噜噜噜噜鲁先生

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java中的类与对象相关的知识，希望对你有一定的参考价值。

什么是类？什么是对象？

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

  • 面向过程

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

  • 面向对象

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

总的来说，需要3个过程

  1. 找对象（由类而来）
  2. 创建对象
  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"。

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

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

1

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

运行结果如下

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

2

方法的访问

通过引用调用方法

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空指针

1

Person person = null;

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

2

Person person = new Person();

Person pppperson = person;

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

3

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()；就是匿名对象调用方法的代码语句。可以看出来，匿名对象是一次性的。

以上是关于Java中的类与对象的主要内容，如果未能解决你的问题，请参考以下文章

Java的类与对象

java中的类与对象

Java中的类与对象

Python 中的类与对象 初认识

java中的抽象类与接口

java类与嵌套嵌套后，怎么使用最外层的类建立对象后使用内部类的方法？