类与对象

• 1.类与对象简介
• 2.类和类的实例化
• 3类的成员
• • 3.1 字段/属性/成员变量
  • 3.2 方法 (method)
  • 3.3 static 关键字
• 4.封装
• • 4.1 private实现封装
  • 4.2 getter和setter方法
• 5. 构造方法
• • 5.1 基本语法
  • 5.2 this关键字
• 6. 认识代码块
• • 6.1 什么是代码块
  • 6.2 普通代码块
  • 6.3 构造代码块
  • 6.4 静态代码块
• 7.匿名对象

1.类与对象简介

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。概念过于抽象，边学边理解。
类就是一类对象的统称。对象就是这一类具体化的一个实例。
面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

2.类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。
简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。
总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型，Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类:

class Person {
       public int age;//成员属性 实例变量
       public String name;
       public String sex;
       public void eat() {//成员方法
              System.out.println("吃饭!");
       }
       public void sleep() {
              System.out.println("睡觉!");
       }
}

用类类型创建对象的过程，称为类的实例化
看下面一个例子

class Person {
      public int age;//成员属性 实例变量
      public String name;
      public String sex;
      public void eat() {//成员方法
             System.out.println("吃饭!");
      }
      public void sleep() {
             System.out.println("睡觉!");
      }
}
      public class Main{
          public static void main(String[] args) {
               Person person = new Person();//通过new实例化对象
               person.eat();//成员方法调用需要通过对象的引用调用
               person.sleep();
               //产生对象        实例化对象
               Person person2 = new Person();
               Person person3 = new Person();
               }
      }

输出结果为

吃饭!
睡觉!

3类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等。

3.1 字段/属性/成员变量

在类中, 但是方法外部定义的变量. 这样的变量我们称为 “字段” 或 “属性"或"成员变量”(三种称呼都可以, 一般不会严格区分)

       public int age;
       public String name;
       public String sex;

上述代码就是Person类中的成员属性
注意：
使用 . 访问对象的字段.
“访问” 既包含读, 也包含写.
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值.
对于各种数字类型, 默认值为 0.
对于 boolean 类型, 默认值为 false.
对于引用类型(String, Array, 以及自定制类), 默认值为 null
null 在 Java 中为 “空引用”, 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常.

3.2 方法 (method)

用于描述一个对象的行为.

class Person {
      public int age = 18;
      public String name = "奥日";
      public void show() {
             System.out.println("我是" + name + ", 今年" + age + "岁");
      }
}
class Test {
      public static void main(String[] args) {
             Person person = new Person();
             person.show();
      }
}
// 执行结果
我是奥日, 今年18岁

此处的 show 方法, 表示 Person 这个对象具有一个 “展示自我” 的行为

3.3 static 关键字

a) 修饰变量(属性)，Java静态变量和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态变量

class TestDemo{
      public int a;
      public static int count;
}

count被static所修饰，所有类共享。且不属于对象，访问方式为：类名 . 属性

静态变量不依赖于对象，要通过类名访问静态变量。
同时静态变量也不能在普通方法里定义。
b) 修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值
看下面一个例子：

class TestDemo{
       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) {
              TestDemo.change()；//无需创建实例对象 就可以调用
              System.out.println(TestDemo.count);
       }
}

注意事项1: 静态方法和实例无关, 而是和类相关. 因此:
静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
注意事项2
我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
main 方法为 static 方法.

4.封装

4.1 private实现封装

private/public 这两个关键字表示 “访问权限控制”。
被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.这里的使用表示可读可写.
public表示公共的，private表示私有的。两者的区别就是访问要求权限的不同.
类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private的成员. 从而让类调用者以更低的成本来使用类.
代码示例：

class Person {
      public String name = "克罗伊";
      public int age = 18;
}
class Test {
      public static void main(String[] args) {
            Person person = new Person();
            System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
      }
}
// 执行结果
我叫克罗伊, 今年17岁

这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的原理, 才能够使用这个类. 使用成本较高。就好像使用电脑要知道电脑内部运行的每个细节一样，太复杂，也不现实。
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高。
而使用private修饰相当一部分变量后，就完成了一部分细节的封装。就好像电脑的内部运行细节，被隐藏起来，用户无需知道原理，只需一些简单的基础知识就可直接使用。
private 不光能修饰字段, 也能修饰方法。
注意：
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为public

4.2 getter和setter方法

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了.
此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法.
代码示例：

class Person {
      private String name;//实例成员变量
      private int age;
      public void setName(String name){
                    //name = name;//不能这样写，两个name都是方法内的局部变量，达不到访问和控制的效果
             this.name = name;//this引用，表示调用该方法的对象
             //this.name表示成员变量，后面的name表示方法内的局部变量
             //以此才能达到访问的效果
      }
      public String getName(){
             return name;//此处的name就是成员变量
      }
      public void show(){
             System.out.println("name: "+name+" age: "+age);
      }
}
public static void main(String[] args) {
       Person person = new Person();
       person.setName("caocao");
       String name = person.getName();
       System.out.println(name);
       person.show();
}
// 运行结果
caocao
name: caocao age: 0

注意
getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置(更改)这个成员的值.
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法

5. 构造方法

5.1 基本语法

构造方法(也称构造器)是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作
new 执行过程
为对象分配内存空间
调用对象的构造方法
语法规则
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法
注意事项
如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致
代码示例

class Person {
    private String name;//实例成员变量
    private int age;
    private String sex;

    //默认构造函数 构造对象
    public Person() {
        this.name = "矛依未";
        this.age = 16;
        this.sex = "女";
    }
    //带有3个参数的构造函数
    public Person(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main{
    public static void main(String[] args) {
        Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person p2 = new Person("亚里莎",19,"女");//调用带有3个参数的构造函数
        p2.show();
    }
}
// 执行结果
name: 矛依未 age: 16 sex: 女
name: 亚里莎 age: 19 sex: 女

5.2 this关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法
代码示例：

class Person {
    private String name;//实例成员变量
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() {
//this调用构造函数
        this("nnk", 19, "woman");//必须放在第一行进行显示
    }
    //这两个构造函数之间的关系为重载。
    public Person(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show() {
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main {
    public static void main(String[] args) {
        Person person = new Person();//调用不带参数的构造函数
        person.show();
    }
}
//执行结果 name: nnk age: 19 sex: woman

我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用。

6. 认识代码块

字段的初始化方式有：

1. 就地初始化
2. 使用构造方法初始化
3. 使用代码块初始化
   前两种方式前面已经学习过了, 接下来我们介绍第三种方式, 使用代码块初始化

6.1 什么是代码块

使用 {} 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块

6.2 普通代码块

普通代码块：定义在方法中的代码块

public class Main{
      public static void main(String[] args) {
           { //直接使用{}定义，普通方法块
              int x = 10 ;
              System.out.println("x1 = " +x);
           }
             int x = 100 ;
              System.out.println("x2 = " +x);
     }
}
// 执行结果
x1 = 10
x2 = 100

这种用法较少见

6.3 构造代码块

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

class Person{
    private String name;//实例成员变量
    private int age;
    private String sex;
    public Person() {
        System.out.println("I am Person init()!");
    }
    //实例代码块
    {
        this.name = "nnk";
        this.age = 19;
        this.sex = "woman";
        System.out.println("I am instance init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
    }
}
// 运行结果
I am instance init()!
I am Person init()!
name: nnk age: 19  sex: woman

注意事项: 实例代码块优先于构造函数执行

6.4 静态代码块

使用static定义的代码块。一般用于初始化静态成员属性

class Person{
    private String name;//实例成员变量
    private int age;
    private String sex;
    private static int count = 0;//静态成员变量 由类共享数据 方法区
    public Person(){
        System.out.println("I am Person init()!");
    }
    //实例代码块
    {
        this.name = "nnk";
        this.age = 19;
        this.sex = "woman";
        System.out.println("I am instance init()!");
    }
    //静态代码块
    static {
        count = 10;//只能访问静态数据成员
        System.out.println("I am static init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();//静态代码块是否还会被执行？
    }
}

注意事项
静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

7.匿名对象

匿名只是表示没有名字的对象.
没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象
代码示例

class Person {
    private String name;
    private int age;
    public Person(String name,int age) {
        this.age = age;
        this.name = name;
    }
    public void show() {
        System.out.println("name:"+name+" " + "age:"+age);
    }
    public void atelier(){
        System.out.println(name+"正在学习炼金术");
    }
}
public class Main {
    public static void main(String[] args) {
        new Person("nnk",19).show();//通过匿名对象调用方法
        new Person("莱莎",17).atelier();
    }
}
// 执行结果
//name：nnk age：19
//莱莎正在学习炼金术

匿名对象是一次性的.使用过一次就失效.