Java 类和对象

类与对象的初步认知

Java是基于面向对象的，关注的是对象，也就是参与过程所涉及的主体，是通过逻辑将一个个功能实现连接起来。类就是一类对象的统称，对象就是这一类具体化的一个实例。简而言之，面向对象就是用类来描述客观世界的事物的一种方式，一个类主要包含一个事物的属性和行为。

类和类的实例化

类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，使用关键字class来声明类，类中的元素称为成员属性，类中的函数称为成员方法。new关键字用于创建一个对象的实例，使用"."来访问对象中的属性和方法。那么接下来废话不多说，先来敲代码：
栗子1：

class Person{
    public int age;//成员属性
    public String name;
    public void eat(){//成员方法
    System.out.println("吃饭！");
    }
}
public class Main{
    public static void main(String[] args){
        Person person1 =new Person();//通过new实例化对象
        Person person2 =new Person();
        person.eat();//调用成员方法
        System.out.println(person.name);//访问成员属性
        System.out.println(person.age);
    }
}

类的成员

类的成员可以包含以下：字段，方法，代码块，内部类和接口等。此处我们只介绍前三个。
字段也称属性、成员变量，也就是前面栗子里面提到的age,name，用于描述一类中包含哪些数据。对于一个对象的字段如果没有设置初始值，那么就会设置一个默认的初值，简单类型是0，boolean是false，String是null，char是’\u0000’。当然也可以给成员变量赋初值，赋值既可以在类里面赋，也可以调用的时候赋。
方法，用于描述一个对象的行为。栗子中的eat就是一个方法，方法中还有一种特殊的方法称为构造方法，在实例化对象的时候会自动调用到的方法，方法名字和类名相同，用于对象的初始化。构造方法会在下下个标题详细介绍，此处便不再赘述。此处需要重点介绍的是static关键字：
static可以修饰属性：Java静态属性和类相关，同一个类的不同实例共享一个静态属性，静态成员变量只有一份，存放在方法区，比如栗子中的person1,person2是同一个类中的不同实例，他们可以有不同的name，age,但是定义静态变量后共享同一个。
static可以修饰方法：在任何方法上应用static关键字，此方法称为静态方法。静态方法属于类，而不属于类的对象；可以直接调用静态方法，无需创建类的实例；静态方法可以访问静态数据成员，但是不能调用非静态方法也不能访问非静态成员变量（反之非静态方法可以调用静态方法也可以访问静态成员变量）。
废话不多说，再来敲代码：
栗子2：

class Test{
    public int a;
    public static int count;
    public static void change(){
        count=100;
        //a=10;error 静态方法不可以访问非静态成员变量
    }
}
public class Main{
    public static void main(String[] args){
        Test.change();//无需创建实例对象，就可以调用
        System.out.println(Test.count)；//可以访问静态成员变量
        //fun();不可以调用非静态方法
    }
    public void fun(){
        Test t=new Test();
        System.out.println(t.a)；
        System.out.println(t.count);//非静态方法可以访问静态成员变量
    }
}

封装

软件开发的本质就是对程序复杂程度的管理。如果一个软件复杂程度太高，就无法继续维护。那如何管理复杂程度？封装就是最基本的方法。封装的本质就是让类的调用者不必太多了解类的实现者是如何实现类的，只要知道如何实现就行了，提高了效率。
那么如何实现封装呢？首先需要用private关键字封装属性，再提供public方法供类的调用者使用。private，私有的，被其修饰后，只能在当前类使用。当我们用private修饰字段的时候，就可以提供一系列getter和setter方法使用它了。
废话不多说，再来敲代码：
栗子3：

class Student{
    private String name;//实例成员变量

    public void show(){
        System.out.println("我叫"+name+"年龄"+age);
    }

    public String getName() {//getter方法，表示获取这个方法的值
        return name;
    }

    public void setName(String name) {//setter方法，表示设置这个成员的值
        this.name = name;//this代表当前对象的引用
    }

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

public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();
        //student.name error 无法访问私有成员变量
        student.show();//调用show方法
        student.setName("bit");
        System.out.println(student.getName());
        System.out.println(student);
    }
}

在栗子3中，name就是私有的，只在student类中使用，但可以在该类中定义public的方法，在main中就可以调用了。另外在IDEA中可以使用alt+insert快速生成setter和getter方法，还有类似于show的toString方法。

构造方法

构造方法是一种特殊的方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作。方法名称必须与类名称相同，构造方法没有返回值类型声明，每一个类至少存在一个构造方法(没有明确定义时，系统自动生成一个无参构造)，另外构造方法也支持重载。
那我们废话不多说，再来敲代码：
栗子4：

class Student{
  public Student(){//默认构造方法
        System.out.println("Student()!");
    }

    public Student(String name){//带一个参数的构造方法
        this.name=name;
        System.out.println("Student(String)!");
    }

    public Student(String name, int age) {//带两个参数的构造方法
    this.name = name;
    this.age = age;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();//调用默认构造方法
        Student student2=new Student("Anna");//调用带一个参数的构造方法
        System.out.println(student2.getName());
        Student student3=new Student("Anna",12);//调用带两个参数的构造方法
    }
}

认识代码块

代码块是使用{ }定义的一段代码。这里介绍三种：本地代码块，实例代码块(也称构造代码块)，静态代码块。说起代码块，不敲代码怎么说呢?
那我们废话不多说，接着敲代码：
栗子5：

class Student{
  private static int count=0;
  private String name;
  public void func(){
        {
            System.out.println("本地代码块");//定义在方法内，没什么用
        }
        System.out.println("func()");
    }

    {   
        this.name="Anna";
        System.out.println("实例代码块/构造代码块");//定义在类中的代码块，一般用于初始化实例成员变量
    }

    static{
        count=10;
        System.out.println("静态代码块");//使用static定义的代码块，一般用于初始化静态成员变量
    }
}

还要注意的就是执行顺序，静态代码块优先于实例代码块，实例代码块优先于构造方法，不过静态代码块与对象无关，只执行一次。

补充说明

这里需要补充说明一下this关键字的用法，1.this.成员变量(非静态成员变量)；2.this();构造方法；3.this.成员方法。
那我们废话不多说，最后敲波代码：
栗子6：

class Person{
    private String name;
    private int age;
    private String sex;

    public Person(){
        this("Anna",18,"woman");//this();构造方法
    }

    public Person(String name, int age, String sex) {
        this.name = name;//this.成员变量
        this.age = age;
        this.sex = sex;
    }

    public void show(){
        System.out.println("name:"+name+"age:"+age+"sex:"+sex);
    }

    public void fun(){
        this.show();//this.成员方法
        System.out.println("fun()");
    }
}

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

okk，Java类与对象就总结到这里啦，码字不易，看到这的同学就给点个赞吧，谢谢！