类定义和使用

面向对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是计算机并不认识洗衣机，需要我们告诉它什么是洗衣机。
上图右侧就是对洗衣机简单的描述，该过程称为对洗衣机对象（实体）进行抽象（对一个复杂事物的重新认识），但是这些简单的抽象结果计算机也不能识别，开发人员可以采用某种面向对象的变成语言来进行描述，比如：Java语言。

类的定义格式

在java中定义类时需要用到class关键字，具体语法如下：

//创建类
class ClassName{
    field;  //字段（属性）或者成员变量
    method;//行为或成员方法
}

class为定义类的关键字，ClassName为类的名字，{}为类中的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

class WashMachine{
	public String brand;
	public String type;
	public double weight;

  public void washClothes(){
  	System.out.println("洗衣服");
  }

  public void dryClothes(){
     System.out.println("脱水");
  }
}

注意：

• 1. 类名采用大驼峰定义。
  2. main方法所在的类一般要用public修饰
  3. public修饰的类必须要和文件名相同
  4. 不要轻易修改public修饰的类的名称，如果要修改，通过Refactor->Rename

类的实例化

什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int、double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一种新的类型，比如刚刚的洗衣机WashMachine类。有了自定义的类型以后，就可以使用这些类来定义实例（或者称为对象）。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Dog {
    public String name;
    public String color;

    public void bark(){
        System.out.println("旺旺旺");
    }

    public void wag(){
        System.out.println("摇尾巴");
    }

    public static void main(String args[]){
        Dog dog1=new Dog();
        dog1.name="大黄";
        dog1.color="黄";
        dog1.bark();
        dog1.wag();

        Dog dog2=new Dog();
        dog2.name="大黑";
        dog2.color="黑";
        dog2.bark();
        dog2.wag();
    }
}

注意：

• 1. new关键字用于创建一个对象的实例。
  2. 使用.来访问对象中的属性和方法。
  3. 同一个类可以创建多个实例。

this 引用

this引用指向当前对象（调用某成员方法的对象），以免因成员变量和形参名相同，造成误解。

public class Date {
    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+"-"+month+"-"+day);
    }

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

this引用的特性

1.this的类型：对应类类型引用，即那个对象调用就是哪个对象的引用类型
2.this只能在“成员方法”中使用
3.在“成员方法”中，this只能引用当前对象，不能再引用其他对象
4.this是“成员方法”第一个隐藏的参数，写不写都无所谓，编译器帮你传递了。

对象的构造及初始化

如何初始化对象

java内部定义一个局部变量时，必须要初始化，否则会编译失败。

要让上述代码通过编译，只需要在正式使用之前，给a设置一个初始值即可。如果是对象：

我们发现，可以正常运行，但只有通过调用setDay方法才能将具体的日期设置到对象中。

我们就此发现两个问题：

1.每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？
2.局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

构造方法

概念

构造方法（也称为构造器）是一个特殊的成员方法，名字必须和类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

特性

1.名字必须与类名相同
2.没有返回值类型，设置为void也不行
3.创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次（相当于人的出生，每个人只能出生一次）。
4.构造方法可以重载（用户根据自己的需求提供不同参数的构造方法）。
5.如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的某人构造方法一定是无参的。

注意：一旦用户定义了构造方法，编译器就不会再生成了，所谓“救急不救贫”。

6.构造方法中，可以通过this调用其他构造方法来简化代码

注意：

1. this（……）必须是构造方法中第一条语句
2. 不能形成环
   7.绝大多数情况下，使用public来修饰，特殊场景下会被private修饰。

封装

封装的概念

面向对象程序三大特性：封装、继承、多态。类和对象阶段，主要研究的就是封装特性。

封装扩展之包

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。也就是位于同一个文件夹下的类。包是对类、接口等的封装机制的体现，是一种对类或接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

导入包中的类

Java中已经提供了很多现成的类供我们使用，例如Date类：可以使用java.util.Date 导入java.util这个包中的Date类。

public class test {
    public static void main(String[] args){
        java.util.Date date=new java.util.Date();
        //获得一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

但是这种写法比较麻烦，可以使用import语句导入包。

import java.util.Date;

public class test {
    public static void main(String[] args){
        Date date=new java.util.Date();
        //获得一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

如果需要使用java.util中的其他类，可以使用import java.util. *

import java.util.*;

public class test {
    public static void main(String[] args){
        Date date=new java.util.Date();
        //获得一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

但是我们更建议显式的指定要导入的类名，否则还是容易出现冲突的情况。如以下案例：
可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class test {
    public static void main(String[] args){
        double x=30;
        double y=40;
        double result = sqrt(pow(x,2)+pow(y,2));
        System.out.println(result);
    }
}

自定义包

基本规则：

• 1.在文件的最上方加上一个package语句指定该代码在哪个包中。
  2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式，例如com.alibaba.demo1
  3.建包方法
  

包的访问权限控制举例

Computer类位于com.bit.demo1包中，TestComputer位于com.bit.demo2包中：

package com.bit.demo1;

public class Computer {
    private String cpu;
    private String memory;
    public String screen;
    String brand;
    
    public Computer(String brand,String cpu,String memory,String screen){
        this.brand=brand;
        this.cpu=cpu;
        this.memory=memory;
        this.screen=screen;
    }
    
    public void Boot(){
        System.out.println("开机");
    }
    
    public void PowerOff(){
        System.out.println("关机");
    }
    
    public void SurfInternet(){
        System.out.println("上网");
    }
}

package com.bit.demo2;
import com.bit.demo1.Computer;
import jdk.swing.interop.SwingInterOpUtils;

public class TestComputer {
    public static void main(String[] args){
        Computer p=new Computer("HW","I7","8G","13*14");
        System.out.println(p.screen);
        //System.out.println(p.cpu);
        //System.out.println(p.brand);
        //cpu 和brand都是私有的，不允许被其他包中的类访问
    }
}

static成员

static修饰成员变量

static修饰的成员变量，称为静态成员变量，不属于某个具体的对象，是所有对象所共享的。
静态成员变量特性：

• 1.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
  2.类变量存储在方法区当中
  3.生命周期伴随类的一生（即：随类的加载而创建，随类的卸载而销毁）

static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public。被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。


静态方法特性：

• 1.不属于某个具体的对象，是类方法
  2.可以通过对象调用，也可以通过类名.静态方法名（…）方式调用，更推荐后者
  3.不能在静态方法中访问任何非静态成员变量（this也不能用）
  4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

static成员变量初始化

静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。
静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。
就地初始化指定是在定义类的时候，直接给出静态成员变量的初始值。

代码块

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

• 普通代码块

• 构造块

• 静态块

• 同步代码块

普通代码块

构造代码块

构造代码块一般用于初始化实例成员变量

静态代码块

一般用于初始化静态成员变量，静态代码块不管生成多少个对象，只会执行一次。

注意：

执行的先后顺序为：
①字段（成员变量）
②静态代码块
③实例代码块
④构造方法
这个执行顺序和他们3个的前后定义顺序没有关系，但如果都是同一类代码块，则执行顺序为定义顺序