java中类与对象回顾总结

一类与对象的定义

类：可以简单理解成是一块模板，是比较抽象的。
对象：就是对于类的实例化，就是具体的，在java中类的实例化通过关键字new来实现。
基本语法规则

//类的创建：
class <类名> {
属性/字段/成员变量
成员方法
}
// 类的实例化：
<类名>+对象名 = new + <类名>();

例如

class Person{
    public String name;//成员属性（成员变量）
    public int age;//成员属性（成员变量）
    public void eat(){//成员方法
        System.out.println("睡觉");
    }

}
public class practiceone{
    public static void main(String[] args) {
      Person person = new Person();//对象的实例化
      person.name="java";//给对象赋值
      person.age = 1;//给对象赋值
      System.out.println(person.name);
      System.out.println(person.age);
      person.eat();
      Person person1 = new Person();
      person1.name="python";
      System.out.println(person1.name);
    }
}

从以上代码示例来看，我们可以发现以下特点：
1 一个类是可以创建多个实例化对象（person，person1）
2 通过关键字new来实例化对象
3 通过.这个来访问对象里的属性以及方法

二类的成员变量

字段/属性/成员变量(普通成员变量)

class Person{
    public String name;
    public int age;//方法之外，类里面的变量称为字段/成员变量/属性
    public void eat(){
        System.out.println("睡觉");
    }

}
public class practiceone{
    public static void main(String[] args) {
        Person person = new Person();//对象的实例化
        System.out.println(person.name);
        System.out.println(person.age);
        }
}

运行结果
null
0

1 对于类里的name,age都属于成员变量
2 如果没有对对象的成员变量设置一个初始值，那么显示的就会是一个默认的初始值，在这里对于各种数字类型，默认的值是0
对于浮点类型，默认的值为0.0
对于字符型，默认的值为’u0000’
对于布尔类型，默认值是false
对于其他引用（String，Array以及定制类），这些的默认值为null。
对于类里面的成员变量是可以直接在类里面赋值的，但我们不希望每一个对象的属性都是一样的，以name为例，不能每一个对象就叫做java
静态成员变量
静态成员变量就是在普通成员变量的形式上，多加了一个Static进行修饰，体会下列代码

class Person{
    public static int count;
    public String name;
    public int age;//方法之外，类里面的变量称为字段/成员变量/属性
    public void eat(){
        System.out.println("睡觉");
    }

}
public class practiceone{
    public static void main(String[] args) {
        Person person = new Person();//对象的实例化
        person.count=10;
        }
 }

其实这个代码看上去是没有什么错的，但是在编译器上，对于person.count会报警告，这就是静态成员变量的特点所决定的，静态成员变量是不依赖于对象的，所以在这里就没有必要实例化对象，静态成员变量是属于类的，所以正确的调用方式应当直接利用类名（Person.count）

class Person{
    public static int count;
    public String name;
    public int age;
    public void eat(){
        System.out.println("睡觉");
    }

}
public class practiceone{
    public static void main(String[] args) {
        Person person = new Person();
        person.age++;
        Person.count++;
        System.out.print(person.age);
        System.out.println(Person.count);
        Person person1 = new Person();
        person1.age++;
        Person.count++;
        System.out.print(person1.age);
        System.out.print(Person.count);
        }
}

运行结果

11
12

图解过程

从以上可以得出，其实我们的静态变量是在方法区中，并且每个对象都是共用一个方法区的，所以才会得出第一个创建对象的count为1，第二个创建对象的count为2.

总结：

1 对于普通成员变量的使用是需要进行对象的实例化，而对于静态成员变量是不依赖于对象的，所以不需要进行对象的实例化，它是属于类的，需要利用类名进行使用。
2 对于静态的成员变量是属于方法区的，不是在堆里。

三类的方法

方法：用来描述对象的行为
对于一种特殊的称为构造方法，在后面的文章中详细讲解，本篇文章主要讲解类的普通方法。

（1）普通成员方法

class Person{
    public static int count;
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"在睡觉");
    }
    public void sleep(){
        change();
        //Static int one = 1;error
        System.out.println(name+"在吃饭");
    }
    public static void change(){
        //sleep()error
        count=10;

    }

}
public class practiceone{
    public static void main(String[] args) {
        Person person = new Person();
        person.name="java";
        person.eat();
        person.sleep(); 
        }
}

在普通成员方法是可以对静态方法进行调用，但是在静态方法里面是不能定义静态成员变量的，这是因为静态成员变量是属于类的，而不属于方法。

（2）静态成员方法

从上面代码分析可以得出，静态成员方法内不能调用普通成员方法，因为静态方法与静态成员变量都是属于类的，不依赖于对象。而普通成员方法依赖于对象。也说明静态方法不能直接使用普通成员变（非静态数据成员）。

类与对象的关键E点：

静态变量与静态方法属于类，而且两者都不依赖于对象
对于普通成员方法以及普通成员变量都必须依赖于对象，换句话说必须要通过关键字new去进行实例化对象。

疑难解答：

问：对于Java中main函数为什么是静态的？
这是因为JVM在底层对于main函数的加载就是使用了静态的，换句话说就是静不静态都是可以的，这个是取决于JVM的（对于JVM的我们后续文章详解）

四 private封装

puplic与paivate两个关键字都是表示访问控制权限，
被puplic修饰的字段和方法，可以直接被类的使用者进行调用，
被private修饰的方法与字段是不可以直接被类的使用者进行调用
对于public修饰进行对象的访问前面我们已经讲解过，这里不多做赘述
下面通过具体的代码来分析一下

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age=10;//error
        person.eat;//error
    }
}

图中标注error的是编译器报错，这个主要就是关键字private的作用了，通过private关键字进行修饰字段与方法，那么该字段与方法的作用范围只能是在当前类下，类的调用者据访问不到这些字段与方法。这个就是我们所说的private封装，封装的作用其实就是为了让代码更加的安全。

五 setter与getter

对于实现private封装的类，里面的字段我们可以通过java中提供的setter于getter方法进行访问。（注意这里是对字段进行访问，方法是不使用这个的）

class Person{
    private int age;
    private String name;
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    private void eat(){
        System.out.println("在睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(10);
        person.setName("java");
    }
}

注意这里的getter与setter方法我们是可以通过IDEA自动帮助生成，通过快捷键Alt+insert就可以进行设置，这个通过自己多动手就知道是怎样生成。

六 toString打印

与getter与setter快捷键一致，可以生成自动将对象转化为字符串的形式输出，这一过程（对象转化为字符串）我们称为序列化。

  @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + ''' +
                '}';
    }

@Override 在 Java 中称为 "注解“，toString 方法会在 println 的时候被自动调用。

七构造方法（重点理解）

在前面我们讲过普通的方法，这里我们需要理解一个特殊并且很重要的一个方法，就是构造方法。构造方法在使用关键字new实例化新对象时会被自动调用,
构造方法的意义：构造对象，对象的实例化。

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
    public Person(){//构造方法
        System.out.println("构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果：

构造方法

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
    public Person(){//构造方法
        System.out.println("构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1=new Person("java");
        Person person2 = new Person("java",1);
    }
}

构造方法要点总结：
从以上我们可以看出构造方法不止一个，可以是多个，并且构造方法之间构成了重载。
构造方法每一个类中至少含有一个，如果自己没有写构造方法，那么编译器自动会生成一个不带任何参数的构造方法，如果自己写了构造方法，那么编译器就不会在生成不带参数的构造方法。

八 this关键字

this要注意的一点就是表示当前对象的引用，而不是当前对象，this一共有三种用法，

1 this调用当前对象的属性（this.data）

class Person {
    private int age;
    private String name;

    private void eat() {
        System.out.println("在睡觉");
    }

    public void setAge(int age) {
        this.age = age;//this调用当前对象的属性
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

2 this调用当前对象的方法（this.func()）

class Person {
    private int age;
    private String name;

    private void eat() {
        System.out.println("在睡觉");
    }
    private void sleep(){
        this.eat();//调用当前对象的方法
        System.out.println("在吃饭");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

3 this调用其他构造函数(this())

class Person {
    private int age;
    private String name;
    public Person(){
        this("java");//调用其他构造函数
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

在这里调用其他构造函数时，this的调用必须放在第一行，如果写入了两个this那么这个时候编译器就会报错，那么两个this里面只能选择一个了。要注意的是这个this（）的使用情况是在一个构造方法里去调用另一个构造方法，在其他情况不能这样用。

九代码块

在这里我们主要介绍实例代码块与静态代码块，对于同步代码块后续的内容会进行阐述，而本地代码块比较简单，这里就不多加以描述。

1 实例代码块

定义：定义在类中的代码块(不加修饰符)。构造代码块一般用于初始化实例成员变量。

2 静态代码块

定义：使用static定义的代码块。一般用于初始化静态成员属性。就是在实例化代码块前加以static修饰，那么此时这个代码块就是静态代码块

3 探究两者之间的关系

class Person {
    private int age;
    private String name;
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果：

静态代码块
实例代码块
不带参数的构造方法

从运行结果上去分析，我们可以看出静态代码块以及实例化代码块都比构造方法更早执行，方法是最后执行的。

class Person {
    private int age;
    private String name;
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("===========");
        Person person1 = new Person("java");
    }
}

运行结果

静态代码块
实例代码块
不带参数的构造方法
===========
实例代码块
带一个参数的构造方法

从上面这一个代码，我们可以看出静态代码块只能执行一次，而实例代码块执行与对象实例化的次数有关。

class Person {
    private int age;
    private String name;
    static int count=10;
    {
        System.out.println("实例代码块");
    }
    static{
        count=90;
        System.out.println("静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果：

静态代码块
90

从以上代码可以看出静态代码是不需要通过关键字new实例化对象就能使用的，而实例化代码块是需要先实例化对象的。

class Person {
    private int age;
    private String name;

    {
        System.out.println("实例代码块");
    }
    static{
        count=90;
        System.out.println("静态代码块");
    }
    static int count=10;
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果：

静态代码块
10

这里对比上一个代码我们发先就是static定义的静态成员变量位置不同，导致count的值不同，说明这个count的值与static执行的顺序有关（这里要特别提一下，static后定义静态成员变量这种java的语法是支持的，不会报错）。在这里有一个特殊的例子，就是count没有初始化值，那么它的值就不与这个执行顺序有关，count就等于99，而不等于10了。

十匿名对象

class Person {
    private int age;
    public String name;
    static int count=10;
    public void eat(){
        System.out.println("睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Person().eat();
    }
}

运行结果：

睡觉

如上代码所示，不需要通过之前那样利用person作为引用去实例化对象，直接通过关键字new创建对象就被称为匿名对象，一个对象只能用一次。

总结：

1 被private修饰的属性，需要通过java提供的setter与getter方法进行访问操作。
2 静态代码块总是最先执行的，并且只执行一次，不需要实例化对象也能执行，实例代码块执行在构造方法之前，构造方法在最后
3 在this这个关键字中，它表示的是对当前对象的引用，不是当前对象。

对于this的详细讲解可以参考以下这篇文章：
this的使用详解

java中类与对象回顾总结

Java相关栏目本月热门文章