类和对象（一）

一、面向对象

（OOP是面向对象的语言的简称）

Java是⼀⻔纯⾯向对象的语⾔，在⾯向对象的世界⾥，⼀切皆 为对象。⾯向对象是解决问题的⼀种思想，主要依靠对象之间的交互完成⼀件事情。

面向对象——>不关注过程，更关注开始结束（如洗衣服，不关注洗衣机工作过程）

（对象=现实生活中的实体）

面向过程——>关注过程，各个环节缺一不可

二、类

1.认识类

类是⽤来对⼀个实体(对象)来进⾏描述的，主要描述该实体(对象)具有哪些属性(外观尺⼨等)，哪些功 能(⽤来⼲啥)，描述完成后计算机就可以识别了。

2.类的定义格式

 // 创建类 
class ClassName{  
    field;        // 字段(属性)或者成员变量
    method;       // ⾏为 或者 成员⽅法
}

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

属性（字段）-->用来描述类-->类的成员属性或者类成员变量

方法（行为）-->说明类具体有哪些功能-->类的成员⽅法

class WashMachine{
public String type;    // 型号
public String brand;   // 品牌 
public double weight;  // 重量 
public double length;  // ⻓ 
public double width;  // 宽 
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.类名注意采⽤⼤驼峰定义（每个单词首字母大写）

2.public修饰的类必须要和⽂件名相同

3.不要轻易去修改public修饰的类的名称，如果要修改，通过开发⼯具修改

三、类的实例化

1.什么是实例化

定义了⼀个类，就相当于在计算机中定义了⼀种新的类型，⽤类类型创建对象的过程，称为类的实例化，在java中采⽤new关键字，配合类名来实例化对象。

 public class Main{
     public static void main(String[] args) {
         PetDog dogh = new PetDog();      //通过new实例化对象

         PetDog dogs = new PetDog();
     }
 }

完成了对象的实例化之后，我们就要去访问对象当中的成员

 class PetDog {
     public String name;//名字
     public String color;//颜⾊
 
     // 狗的属性 
     public void barks() {
         System.out.println(name + ": 旺旺旺~~~"); 
     }

     // 狗的⾏为
     public void wag() {
         System.out.println(name + ": 摇尾巴~~~");
     }
 }

 public class Main{
     public static void main(String[] args) {
     PetDog dogh = new PetDog();     //通过new实例化对象 
     dogh.name = "阿⻩";
     dogh.color = "⿊⾊";
     dogh.barks();
     dogh.wag();
 
     PetDog dogs = new PetDog();
     dogs.name = "小黑";
     dogs.color = "⻩⾊";
     dogs.barks();
     dogs.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 + "/" + this.month + "/" + this.day);
     }

     public static void main(String[] args) {
         // 构造三个⽇期类型的对象 d1 d2 d3 
         Date d1 = new Date();
         Date d2 = new Date();
         Date d3 = new Date();

         // 对d1，d2，d3的⽇期设置 
         d1.setDay(2020,9,15);
         d2.setDay(2020,9,16);
         d3.setDay(2020,9,17);
         
         // 打印⽇期中的内容 
         d1.printDate();
         d2.printDate();
         d3.printDate();
     }
 }

这里如果删去三个this，那么就会产生两个错误：

1.=两边同名，成为了自己给自己赋值，程序报错。

2.三个调用，三个打印，分不清谁的给谁。

this代表的 是当前对象的引⽤，当前对象就是指：哪个对象调⽤setDay⽅法，谁就是this引⽤！

#注：

1.this的类型：对应类类型引⽤，即哪个对象调⽤就是哪个对象的引⽤类型

2.this只能在"成员⽅法"中使⽤

3.在"成员⽅法"中，this只能引⽤当前对象，不能再引⽤其他对象

4.this是“成员⽅法”第⼀个隐藏的参数，编译器会⾃动传递，在成员⽅法执⾏时，编译器会负责将 调⽤成员⽅法对象的引⽤传递给该成员⽅法，this负责来接收

五、对象的构造及初始化

1.默认初始化

对于成员变量来说，如果没有进⾏初始化，会有⼀个对应的0值

（其中布尔类型默认为FALSE，抽象类默认为null）

2.就地初始化

在声明成员变量时，就直接给出了初始值。

 public class Date {
     public int year = 1900;
     public int month = 1;
     public int day = 1;
 
     public Date(){
     }
 
     public Date(int year, int month, int day) {
     }
     
     public static void main(String[] args) {
         Date d1 = new Date(2021,6,9);
         Date d2 = new Date();
     }
 }

3.构造⽅法初始化

构造⽅法是⼀个特殊的成员⽅法，名字必须与类名相同，在创建对象时，由编译器⾃动调⽤，并且在整个对象的⽣命周期内只调⽤⼀次。

 public class Date {
     public int year;
     public int month;
     public int day;
 
     public Date(int year, int month, int day){
         this.year = year;
         this.month = month;
         this.day = day;
         System.out.println("Date(int,int,int)⽅法被调⽤了");
     }

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

     public static void main(String[] args) {
        // 此处创建了⼀个Date类型的对象，并没有显式调⽤构造⽅法 
        Date d = new Date(1999,6,9);   // 输出Date(int,int,int)⽅法被调⽤了 
        d.printDate();    //1999-6-9
     }
 }

#注：

1.名字必须与类名相同

2.没有返回值类型，设置为void也不⾏

3.创建对象时由编译器⾃动调⽤，并且在对象的⽣命周期内只调⽤⼀次(相当于⼈的出⽣，每个⼈只能 出⽣⼀次)

4.构造⽅法可以重载

5.如果⽤⼾没有显式定义，编译器会⽣成⼀份默认的构造⽅法，⽣成的默认构造⽅法⼀定是⽆参的。

6.⼀旦⽤⼾定义了其他的构造⽅法，编译器则不再⽣成。

7.构造⽅法中，可以通过this调⽤其他构造⽅法来简化代码

（this(...)必须是构造⽅法中第⼀条语句！！！ 不能形成环的调⽤！！！）

六、对象的打印

如果我们直接打印对象的引⽤，此时输出的结果为：类路径名@对象的hashcode值。

因此，我们会使用重写toString⽅法打印对象

 public class Person {
     String name;
     String gender;
     int age;
 
     public Person(String name, String gender, int age) {
         this.name = name;
         this.gender = gender;
         this.age = age;
     }

     @Override
     public String toString() {
         return "[" + name + "," + gender + "," + age + "]";
     }

     public static void main(String[] args) {
         Person person = new Person("Jim","男", 18);
         System.out.println(person);
     }
 }

 // 输出结果：[Jim,男,18]