类与对象

类

类的类型是引用类型

类主要使用来对一个实体（对象）来进行描述

类：自定义类型（高配结构体）
对象：（自定义类型创建出来的变量）

类相当于把 现实事物 的 属性 和 行为 结合到一起了

光有一个类还不够，还需要根据这个类创建出一些具体的对象来，这个操作也称为 “实例化”。

当创建好对象/实例之后，最核心的操作就是访问成员，可以是访问成员变量（属性），访问成员函数（方法）。

同一个包里不能又两个相同名字的类，同名字的类是可以在不同的包中的。

类的定义和使用

类的定义格式

在 Java 中定义类是需要用到 class 关键字
基本格式：

class Person {
public 类型 变量名;//成员属性
public 类型 方法名() {//成员方法
      执行的方法
}

class 为定义类的关键字，Person 为类的名字，{} 中为类的主体。
类中包含的内容成为类的成员。
变量信息主要对类进行描述，称之为类的成员属性或者类成员变量。
方法主要说明类具体有哪些功能，成为类的成员方法

注：

• 类名注意采用大驼峰定义
• 成员属性的定义
• 析出写的方法不带 static 关键字

类的实例化

什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与interesting， double 类似，只不过 int 和 double 是Java 语言自带的内置类型，而类是用户自定义了一个新的类型。

用类类型创建对象的过程，称为类的实例化，在 Java 中采用 new 关键字，配合类名来实例化对象

public class A {
    public int name;
    public String sex;

    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }
    
    public static void main(String[] args) {
        A a = new A();//通过 new 实例化对象
        A a1 = new A();//实例化对象
        A a2 = new A();
        a.eat();//成员方法调用需要通过对象的引用调用
        a.sleep();
    }
}

注：

• new 关键字由于常见一个对象的实例
• 使用 “.” 来访问你对象中的属性和方法
• 同一个类可以创建多个实例

类和对象的说明

• 类只是一个模型一样的东西，用来对一个实例进行描述，限定了类有哪些成员
• 类是一种自定义的类型，可以用来定义变量，但是在 Java 中用类定义出来的变量我们称为对象
• 一个类可以实例化出很多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

类的成员

字段/属性/成员变量

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

• 使用 “.” 访问对象那个的字段
• “访问” 即包含读，也包含写
• 对于一个对象的字段如果没有显式设置初始值，那么会被设置一个默认的初值

static 关键字

修饰属性

Java 静态属性和类无关，和具体的实例有关. 换句话说，同意个类的不同实例共用一个静态属性.

    class TestDemo{
        public int a;
        public static int count;
    }
    public class Main{
        public static void main(String[] args) {
            TestDemo t1 = new TestDemo();
            t1.a++;
            TestDemo.count++;
            System.out.println(t1.a);
            System.out.println(TestDemo.count);
            System.out.println("============");
            TestDemo t2 = new TestDemo();
            t2.a++;
            TestDemo.count++;
            System.out.println(t2.a);
            System.out.println(TestDemo.count);
        }
    }

修饰方法

如果在任何方法上应用 static 关键字，此方法成为静态方法

• 静态方法属于类，但不属于类的对象
• 可以直接调用静态方法，但无需创建类的实例
• 静态方法可以访问静态数据成员，并可以更改静态数据成员的值
  **注1：**静态方法和实例无关，而是和类相关,因此导致了个情况
• 静态方法不能直接使用非静态数据成员或调用非静态方法（非静态数据成员和方法都是和实例相关的）
• this 和 super 两个关键字不能再静态上下文钟使用（this 是当前实例的引用，super 是当前实例父类实例的引用，也是和当前实例相关）

this

this 引用的特性

1. this 指向当前对象的引用
2. this 的类型就是当前这个类的类型
3. this 这个引用的指向不能修改
4. this 也可以用来调用方法
5. this 不能是 null

什么是 this 引用

public class A {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }


    public static void main(String[] args) {
        A d = new A();
        d.setDay(2020, 9, 15);
        d.printDate();
    }
}

注：
this 引用的是调用成员方法的对象

final 关键字

final 修饰一个变量，表示是常量。如果修饰的是一个引用类型，表示该引用的指向不能修改（引用中存的地址不能改）
final 修饰一个类，表示这个类不能被其他类继承

private关键字

private / public 这两个关键字表示（访问权限控制）

• 被 public 修饰的成员变量或者成员方法，可以直接被类的调用者使用
• 被 private 修饰的成员变量或者成员方法，不能直接被调用者使用

注：
private 不光能修饰字段，也能修饰方法

Java 中对于对象的初始化方法

1.默认值

不同类型的默认值不一样

2.就地初始化

3.代码块初始化

4.构造方法初始化

构造方法初始化是一种特殊的方法：

1. 构造方法的方法名是固定的，必须和类名相同
2. 构造方法不需要 return 语句，但是可以理解成返回了该对象的引用
3. 构造方法不需要显式调用，而是在 new 的时候被自动调用
4. 构造方法也支持重载，重载规则和普通方法一样

static成员

如果类中的某个成员加上了 static ，说明这个成员式一个 类属性/类方法 ，如果没有 static ，成员是一个 实例属性/实例方法

static 修饰代码块，代码块只是在类加载的时候执行一次
往往用来初始化静态成员

修饰属性

Java 静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同实例公用同一个静态方法。

静态方法

任何方法上应用了 static 关键字，此方法称为给静态方法

• 静态方法属于类，而不属于类的对象
• 可以直接调用静态方法，而无需要创建类的实例
• 静态方法可以访问静态数据成员，并可以更改静态数据成员的值

静态方法中不能是由 this
this 指向的是当前的实例.
static 方法和实例无关，只和类有关
同理也无法在 static 方法中访问非 static 的变量和方法

toString方法

• toString 方法会在 println 的时候被自动调用
• 将对象转成字符串这样的操作我们称为 序列化.
• toString 是 Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object 类, 可以重写 toString 方法实现我们自己版本的转换字符串方法
• @Override 在 Java 中称为 “注解”, 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法

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);
     }
   //重写Object的toString方法
    @Override
    public String toString() {
    return "Person{" +
           "name='" + name + '\'' +
           ", age=" + age +
            '}';
     }
}
public class Main {
     public static void main(String[] args) {
       Person person = new Person("caocao",19);
       person.show();
       System.out.println(person);
  }
}

访问限定符

public：修饰的成员可以被外部的类随意访问
private：只能在类内部使用
protect：搭配继承
default（不写）：包级权限

• public：类内部和类的调用者都能访问
• private：类内部能访问，类外部不能访问
• protect：类内部能访问，子类同一个包中的类可以访问，其他类不能访问
• default（默认）：类内部能访问，同一个包中的类可以访问，其他类不能访问

一般的原则，是一个成员能使 private 就尽量设定成private.

public 修饰的成员访问权限最大，default 其次，private 最小

代码块

什么是代码块

使用 {} 定义的一段代码
根据代码块定义的位置一级关键字，又可以分为四种

• 普通代码块
• 构造块
• 静态块
• 同步代码块

普通代码块

定义在方法中的代码块

public class Test{
    public static void main(String[] args){
       {
       //代码块内容
       }
    }
}

构造代码块

定义在类中的代码块（不加修饰符），也叫：实例代码块
注:
实例代码块优先于构造函数执行

public class Test{
       {
       //代码块内容
       }
    public static void main(String[] args){

    }
}

静态代码块

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

• 静态代码块不管生成多少个对象，指挥执行一次，且最先执行
• 静态代码块执行完毕后，实例代码块执行，然后是构造函数执行

public class Test{
       static{
       //代码块内容
       }
    public static void main(String[] args){

    }
}

内部类

普通的内部类/成员内部类

作为对象的一个成员来定义的类
基本格式：

public class Test {
class C{
   }
}

public class Test {
public static void main(String[] args) {
      C c = new Test();
}
class C{
   }
}

静态内部类（内部类前面用 static）

基本格式：

 public class Test {
static class B{
     }
}

例：

public class A {
static class B{
}
public static void main(String[] args) {
B b1 = new B();
B b2 = new B();
   }
}

匿名内部类（相对比较常用）

定义：在一个方法或是代码块中定义的类，并且没有显示声明类的名称

public class Test {
public static void main(String[] args) {
      //定义了一个匿名内部类
      A a = new A(){
        };
     }
}
class A{
}

局部内部类（不用）

public class Test {
     public static void main(String[] args) {
     class D extends A{
        }
     System.out.println(new D());
     }
}
class A{
}