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

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>