1.类和对象的定义

对象：Java中一切皆对象。

类：一般情况下一个Java文件一个类，每一个类对应一个字节码文件（*.class）

1）字段 / 属性 / 成员变量：定义在类中，方法的外面；2）方法

类似于C语言的结构体。

成员变量未初始化时都有一个默认值：引用类型默认值为null；int类型默认值为0；float类型默认值为0.0f；char类型默认值为'\u0000'；boolean类型默认值为false

class WashMachine{//类
    //字段/属性/成员变量
    public String brand;
    public String type;
    public double weight;
    public double length;
    public double height;
    public String color;
    //成员方法
    public void washClothes(){
        System.out.println("洗衣功能");
    }
    public void dryClothes(){
        System.out.println("脱水功能");
    }
    public void setTime(){
        System.out.println("定时功能");
    }
}

注意：

1> idea中如何打开当前类所在文件夹：*. java + 右键 +Open in + Explorer;

2> 当类由public修饰时，类名必须和文件名一致；

3> 不要轻易去修改public修饰的类的名称，若要修改:文件名 + 右键 + Refactor + Rename；

4> 类中的方法不需要static修饰。

2.关键字new

public static void main(String[] args) {
    WashMachine washmachine1 = new WashMachine();
    WashMachine washmachine2 = new WashMachine();

    //赋值
    washmachine1.brand = "海尔";
    washmachine2.brand = "小天鹅";

    //washmachine：引用变量，存了对象的地址——>实例化对象
    System.out.println(washmachine1.brand);
    System.out.println(washmachine2.brand);

    washmachine1.washClothes();
    washmachine2.washClothes();
}

注意：

1> 可以使用关键字new实例化多个对象；

2> 同一个类可以创建多个实例；

3> 使用 . 来访问对象中的属性和方法。

3.this引用

public class TestDate {
    public int year;
    public int month;
    public int day;
    public void setDate(int y,int m,int d){
        //谁调用了setDate，this就是谁
        this.year = y;
        this.month = m;
        this.day = d;
    }
    public void printDate(){
        //要习惯加上this
        System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    }

    public static void main(String[] args) {//main方法可以定义在类当中
        //定义
        TestDate testDate1 = new TestDate();
        TestDate testDate2 = new TestDate();
        TestDate testDate3 = new TestDate();
        //赋值
        testDate1.setDate(2000,2,28);
        testDate2.setDate(2022,12,21);
        testDate3.setDate(2023,3,12);
        //打印
        testDate1.printDate();
        testDate2.printDate();
        testDate3.printDate();
    }
}

注意：

1> this对应类型引用，哪个对象调用就是哪个对象的引用类型；

2> this只能在普通成员方法中使用，静态成员方法（static修饰）中不能使用；

3> 在成员方法中，this只能引用当前对象，不能再引用其他对象；

4> this时成员方法第一个隐藏的参数，编译器会自动传递。

4.对象的构造及初始化

普通方法：返回值+方法名+（参数列表）+ {方法体}

构造方法：没有返回值且方法名必须和类名保持一致

//注意方法名与类名一致！！！
public TestDate(){
    System.out.println("没有参数的构造方法");
}
public TestDate(int year,int month,int day){ //两个方法构成了重载
    this.year = year;
    this.month = month;
    this.day = day;
    System.out.println("有3个参数的构造方法");
}

注意：

1> 构造方法可以重载（方法名均为类名）；

2> 构造方法一个都没写的情况下，编译器会帮你默认生成一个不带参数的构造方法；但当你写了其中任意一种构造方法，其它构造方法编译器不会帮你生成；

3> 构造方法一定会被调用，具体调用哪个构造方法得看有没有相应的参数；

3> 一个对象的产生至少有以下2步：为对象分配内存，调用合适的构造方法；

4> idea自动生成构造方法：右键 + Generate + Constructor + 自选；

5> 可在构造方法中使用this()来调用另一个构造方法且必须放在第一行，但是不能自己调用自己。

class Student{
    public String name;
    public int age;
    public Student(){ //此为没有参数的构造方法
        this("wangwu",20);//this()必须放在第一行
        System.out.println("调用第一个");
        this.print();//利用this调用其他成员方法，可以不放在第一行
    }
    public Student(String name,int age){//此为有两个参数的构造方法
        this.name = name;
        this.age = age;
        System.out.println("调用第二个");
    }
    public void print(){
        System.out.println("姓名："+this.name+"年龄："+this.age);
        //注意这里不加this输出 姓名：null年龄：0
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();//调用上面第一个构造函数
        student1.name = "zhangsan";
        student1.age = 18;
        Student student2 = new Student("lisi",19);//调用上面第二个构造函数
        student2.print();
    }
}

5.封装

面向对象程序三大特性：封装、继承、多态。这里先介绍封装的概念。

定义：将类的实现细节进行隐藏，类外看不见数据，实现了类的安全性。

注意：defaule是什么都不写时的默认权限

访问限定符
No	范围	private	default	protected	public
1	同一包中的同一类	√	√	√	√
2	同一包中的不同类	×	√	√	√
3	不同包中的子类	×	×	√	√
4	不同包中的非子类	×	×	×	√

//包的概念

定义：多个类收集在一起成为一组，称为软件包，类似于目录。

导入：可以让编译器自动导入，也可以手动导入。

通配符*：可以充当任何类。如util.* 不是导入util下的所有类，而是用到哪个类就用哪个类。

但是当使用的类在多个包中都有时，需要手动导入。非必要不用*。

自定义包：在文件最上方加上一个package语句指定改代码在哪个包中。

//如何访问

前面我们说了用private修饰之后，类外就不能使用类内的变量了，那无法访问有什么意义呢？别急，强大的idea可以帮我们用另一种方法访问：

class Student{
    private String name;//私有，无法在类外访问
    private int age;//同上

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("wangwu");//利用setName和getName访问
        System.out.println(student.getName());
        student.setAge(20);
        System.out.println(student.getAge());
    }
}

6.static成员

特点：1）修饰成员变量或方法，称为类变量/静态成员变量或类方法，不能修饰局部变量；

2）不依赖对象，不需要new对象，所有对象共用一份；

3）静态方法内部不能调用非静态方法，不能使用this，无法重写；

4）存储在方法区当中，生命周期伴随类的一生。

访问方式：虽然可以但是不建议通过对象来引用访问，而是通过类名访问。

class Student{
    private String name;//普通成员变量，每个对象都有一份
    private int age;//普通成员变量
    public static String classroom = "301";//被static修饰，称为类变量/静态成员变量，所有对象共用一份

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public static void func() {
        System.out.println("func……");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",20);
        Student student2 = new Student("lisi",21);
        Student student3 = new Student("wangwu",22);//这些对象都可以不new，不影响类变量和类方法的调用
        /*System.out.println("教室是"+student1.classroom);//结果是一样的
        System.out.println("教室是"+student2.classroom);
        System.out.println("教室是"+student3.classroom);*///虽然可以但是不建议通过对象来引用访问
        System.out.println("教室是"+Student.classroom);//而是通过类名直接访问;
        Student.func();
    }
}

7.代码块

分类：静态代码块，实例代码块，同步代码块，普通代码块

注意：

1）顺序：静态代码块 > 构造代码块 > 构造方法；

2）静态代码块不管生成多少个对象，都只执行一次；

3）如果一个类中包含多个静态代码块，编译器会按照顺序依次执行。

class Student {
    private String name = "lisi";
    private int age;
    {
        this.name = "zhangsan";//按顺序执行这一行代码，名字为zhangsan
        System.out.println("构造块！");
    }
    static {
        classroom = "201";
        System.out.println("静态代码块！");
    }
    public static String classroom = "208";//按顺序执行这一行代码，班级为208

    public Student() {
        System.out.println("调用不带参数的构造方法！");
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("调用带两个参数的构造方法！");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(Student.classroom);//208
        System.out.println(student.getName());//zhangsan
    }
}

8.对象的打印

编译器自己生成（方法重写）：右键 + Generate + toString() + 自选

class Student {
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override//方法重写，重写了toString方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void print() {
        System.out.println("姓名:"+this.name+" 年龄："+this.age);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("zhangsan",20);
        System.out.println(student);//没重写时，打印student的地址
        student.print();//正常调用上面的成员方法
    }
}