目录

一.类的定义

1.普通成员变量

2.静态成员变量

二.成员变量的封装

三.构造方法

1.构造方法的定义和使用

2.构造方法的重载

 3.this的使用

四.代码块

1.实例代码块

2.静态代码块

五.匿名对象

一.类的定义

我们在写Java代码的时候，一定会写下这样一段代码：

    public class Test{
    public static void main(String[] args) {

        }
    }

在代码的第一段我们可以看到public class，那么这其实就是一个类，但是在一个Java文件当中是只有一个public类的，我们在之前的博客当中也有所介绍就不在此赘述了。

虽然我们只能定义一个public类，但是我们还可以定义其它的一些非公共类以满足我们编程的需要：

class Person {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name + "正在吃饭");
    }
}
public class Test{
    public static void main(String[] args) {

        }
    }

1.普通成员变量

我们现在定义了一个类，类的名字叫Person。类当中的name，age我们叫做成员变量也可以叫字段，同时这个类当中还包括了一个成员方法。那么我们该怎样来使用它呢？

class Person {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name + "正在吃饭");
    }
}
public class Test{
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "张三";
        person1.age = 20;
        person1.eat();
        }
    }

我们z可以在main方法当中定义一个叫person1的Person类并将其实例化。我们发现当我们需要定义person1内成员的值时都得通过person1这个对象来实现。这里我们需要强调一个知识点：成员变量前的限定修饰符如果是public，那么我们在修改成员赋值的时候都得通过实例化的对象来实现。我们可以通过下面这幅图来表达一下他们之间的关系方便大家理解：

 我们实例化一个对象之后，对象名在栈上储存的是一个地址，该地址指向堆上开辟的一个空间，堆上储存的才是该对象的内容。也就是说，如果我们没有实例化一个对象，那么堆上也就不会有对应的空间开辟来储存相应对象的数据。

2.静态成员变量

像age和name这样的成员其实是依赖对象而存在的。那么有没有不依赖对象存在的成员呢？答案是肯定的。

我们来看一下下面这段代码：

class Person {
    public String name;
    public int age;
    public static int count;
    public void eat() {
        System.out.println(name + "正在吃饭");
    }
}
public class Test{
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.age++;
        person1.count++;
        System.out.println(person1.age);
        System.out.println(Person.count);
        System.out.println("===================");
        Person person2 = new Person();
        person2.age++;
        person2.count++;
        System.out.println(person2.age);
        System.out.println( Person.count);;
        }
    }

运行后：

person1和person2的age是互不相干的，这说明在实例化多个对象时，Java会给每一个对象在堆上各自开辟一个空间互不干扰。而打印count的时候我们发现， 他们使用++指令的都是同一个成员。我们观察代码会发现count成员与age不同的是，除了public它还被一个static修饰着。

我们管被static修饰的成员变量叫静态成员变量。静态成员变量既不储存在栈上也不储存在堆上，它储存在方法区上。而静态成员变量是直接属于类的，并不依赖于实例化的对象而存在，我们在使用它的时候可以直接通过类名来调用。

对于静态成员变量有以下几点需要注意：

1.静态成员变量不能再方法中定义。

2.静态成员方法里不能调用普通成员变量，但普通方法可以调用静态变量。

3.静态的成员和方法不依赖对象。 

二.成员变量的封装

 我们在定义完一个类之后，类当中的成员我们在使用的时候需要我们去赋值。那么，如果类当中的一个成员变量被修改了名字，那么我们在后面对它的赋值和调用都会因为它名字的改变而失效报错。因此我们需要一个更安全的方法去保护这些成员变量——封装。

我们先前在定义成员变量时用的限定修饰符为public，而封装后是将public改为private来修饰：

class Per {
    private String name;
    private int age;
}

被private修饰的成员变量将不能在类外使用和赋值，因此我们需要给他们提供一个公用的接口，用来对成员变量进行修改和赋值：

class Per {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

每个成员对应的get方法和set方法我们可以自己编写也可以使用IDEA自动生成，具体方法为：

1.右键选择Generate

2. 选择Getter and Setter

 3.选择你想要的生成方法的变量

完成之后我们就可以使用了：

class Per {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}
public class Test{
    public static void main(String[] args) {
        Per person = new Per();
        person.setName("张三");
        person.setAge(20);
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }
}

运行结果：

 注意：如果是自己编写以上方法，在对成员变量进行赋值的时候应习惯在成员变量前使用this。

例如：

    public void setName(String name) {
        this.name = name;
    }

this代表的是对当前对象的引用，假如没有使用this，上述代码便无法正常运行。

总结：

1.被public修饰的成员变量或者成员方法可以直接被类的调用者使用。

2.被private修饰的成员变量或者成员方法可以不能被类的调用者使用。

三.构造方法

1.构造方法的定义和使用

构造方法的方法名与类名相同，且构造方法较为特殊，它是没有返回值的。那么构造方法在类当中扮演者一个什么样的角色呢？

一个对象的实例化可以分为两步：1.为对象分配内存  2.调用合适的构造方法。也就是说构造方法是用来实例化对象的。我们来写一写构造方法：

class Per {
    private String name;
    private int age;

    public Per() {
        System.out.println("无参数的构造方法");
    }
}
public class Test{
    public static void main(String[] args) {
        Per person = new Per();
    }
}

当我们实例化一个对象并运行的时候：

当我们没有自己定义 构造方法时，Java会默认使用无参数的构造方法。

2.构造方法的重载

我们刚刚说，针对不同情况，Java会调用合适的构造方法。这意味着构造方法并不是唯一的，因此构造方法也是满足重载的。

class Per {
    private String name;
    private int age;

    public Per() {
        System.out.println("无参数的构造方法");
    }
    public Per(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("两个参数的构造方法");
    }
}
public class Test{
    public static void main(String[] args) {
        Per person  = new Per();
        System.out.println("================");
        Per person2 = new Per("张三",20);
    }
}

我们在实例化对象的时候Java会根据我们在构造方法中输入的参数个数和类型来选择调用合适的构造方法。运行结果：

 3.this的使用

this一般有以下三种使用方法：

1.调用当前对象的属性

    public void setName(String name) {
        this.name = name;
    }

2.调用当前对象的方法

class Person {
    public String name;
    public int age;
    public static int count;
    public void eat() {
        System.out.println(name + "正在吃饭");
    }
    public void eat2() {
        this.eat();
}

3.调动当前对象的其他构造方法

注意：this（）只能在构造方法内使用，且只能放在构造方法的第一行。

public Per() {
        this("name", 20);
        System.out.println("无参数的构造方法");
    }
    public Per(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("两个参数的构造方法");
    }

四.代码块

字段的初始化有三种方法：

1.就地初始化

2.使用构造方法初始化

3.代码块初始化

代码块可以分为三类：

1.实例代码块

2.静态代码块

3.本地代码块

4.同步代码块

今天我们只介绍前两种

1.实例代码块

代码示例：

class Per {
    private String name;
    private int age;
    
    {
        System.out.println("实例代码块");
    }
}

2.静态代码块

代码示例：

class Per {
    private String name;
    private int age;
    
    static{
        System.out.println("静态代码块");
    }   
 }

我们来看下面一段代码：

class Per {
    private String name;
    private int age;
    
    {
        System.out.println("实例代码块");
    }

    static{
        System.out.println("静态代码块");
    }
    
    public Per() {
        this("name", 20);
        System.out.println("无参数的构造方法");
    }
}
public class Test{
    public static void main(String[] args) {
        Per person1 = new Per();
        System.out.println("=============");
        Per person2 = new Per();
    }
}

我们实例化了两个对象，中间用符号分隔开，我们来看一下运行结果：

注意：我们一开始是将示例代码块写在静态代码块之前的，但是运行时却是先执行静态代码块。从上述代码的运行结果我们可以总结出：

1.静态代码块一定先于实例代码块执行。

2.静态代码块只在第一次实例化该类型的对象时执行。 

另外，静态代码块就算不实例化对象也能执行，且只执行一次。

五.匿名对象

匿名对象：

1.没有引用的对象叫匿名对象

2.匿名对象只能在创建对象时使用

3.匿名对象只能使用一次

代码示例：

    public static void main(String[] args) {
        new Person().eat();
    }

以上就是这次类和对象的全部内容了，创作不易喜欢的话就请点个赞吧！