Java的类和对象

目录

前言

一、什么是类？

二、类如何产生对象

三、对象引用

总结 ：暂时写到这，持续更新中

---

前言

----------------------------------------总所周知Java 是一个面向对象的语言---------------------------------------

一、那么什么是面向过程？什么是面向对象？

✋面向过程就好比你要去做完成一件事，你注重完成这件事情的每一个步骤；

✋面向对象就是你把你要完成的事情相关联的步骤封装成一个，这样就可以把一件需要多数步骤        完成的事情，变成少数步骤；

例：👀面向过程：你要吃饭--------->你要先买菜，买完菜洗菜，洗完菜然后切菜，切完菜，你先                                   热锅 下油，之后再炒菜，再然后洗米，煮饭..o_o ...最后你才能吃上一顿饭；

       👀 面向对象：你要吃饭--------->下馆子，付钱，等一会就能吃上饭；

就像这样面向对象就不需要管菜是如何如何做的，饭是如何如何洗的，就能吃上饭了 "(￣_,￣ )"

😺 java中定义类，再通过引用类来实例化对象，所以有了类就有了对象，有了对象就可以面向对         象 ，下面介绍一下什么是类与类如何产生对象(ง •_•)ง

---

一、什么是类？

  😺 类是一个类型，定义一个类相当于在计算机中定义一个新的类型，类似与int 、double 之类             的，  区别就是这个是自己抽象出来的。 

1、定义类（自定义类型）

😺语法：class  类名  { //类里面有字段与方法；

                    //1、字段（成员变量）也可以叫做属性

                    //2、方法（成员方法）也可以叫做行为

                } ；   

😺注意：成员变量是定义在类里面，方法外面的；定义在方法里面的变量是局部变量而不                    是 成 员变量；还有命名规则：大驼峰(首字母大写)   例 洗衣机 WashMachine；

😺代码示例：

class WashMachine{
//字段or属性
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double lenght; // 长
public double weidth; // 宽
public double height; // 高
public String color; // 颜色
//方法or行为
public void WashClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void SetTime(){ // 定时
System.out.println("定时功能");
}
}

😺注意事项：

1. 一般一个文件当中只定义一个类

2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

3. public修饰的类必须要和文件名相同

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

二、类如何产生对象

 ✋类只是一个模型一样的东西，相当于一个设计，用类创造对象的过程称为类的实例化

例：

//通过new关键字实例化了一个对象
WashMachine wc = new WashMachine();

   此过程的内存图如下：

 ✋变量wc是局部变量 里面存储的是 new 对象的地址，是引用型变量，通过对象的地址  点(.)  成        员变量名，就可以访问成员变量了

 例：

System.out.println(wc.type);
System.out.println(wc.brand);
System.out.println(wc.weight);

✋值得注意的是，局部变量里边使用时需要初始化，但成员变量不用，他在默认情况下引用数据        类型为null,基本数据类型为0，基本数据类型的boolean为false, char 为 \u000;

✋访问成员方法也是同理，通过对象的引用 点（.）方法名

wc.WashClothes();
wc.dryClothes();

✋类只是一个模型一样的东西，相当于一个设计，通过一个类 ，可以实例多个对象，对象间互不      干扰，只有实例化对象出来才能实际存储数据，占用物理空间来存储类里边的成员变量；

     例：

public class Date {
    public int year;
    public int month;
    public int day;
    public void setDay(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }

    public static void main(String[] args) {

// 构造三个日期类型的对象 d1 d2 d3 并对d1，d2，d3的日期设置
        Date d1 = new Date();
        d1.setDay(2020,9,15);
        
        Date d2 = new Date();
        d2.setDay(2020,9,16);
        
        Date d3 = new Date();
        d3.setDay(2020,9,17);
      
// 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }


}

三、对象引用

1、this引用 

    为什么要this引用

public class Date {
    public int year;
    public int month;
    public int day;
     //========下面这一部分
    public void setDay(int  year , int month, int  day){ 
        year =  year ;            //========看过来，是这一部分
        month = month;         //========对，就是这一部分
        day =  day;            //========这一部分
    }

       //========上面这一部分
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }


    public static void main(String[] args) {

// 构造三个日期类型的对象 d1 d2 d3 并对d1，d2，d3的日期设置
        Date d1 = new Date();
        d1.setDay(2020,9,15);
        
        Date d2 = new Date();
        d2.setDay(2020,9,16);
        
        Date d3 = new Date();
        d3.setDay(2020,9,17);
      
// 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }


}

👀如上注释所指的这一部分，形参名跟变量名相同，运行之后结果为零

😺原因是因为形参是局部变量，局部变量优先权大（范围越小的优先权越大），所以编译器就都       认为里面都是形参变量，也就造成了形参给形参赋值的的情况，也就没有给成员变量赋值，所       以结果也就为零，因为里面根本引用不到成员变量。

😺解决思路，让编译器认出他是成员变量--怎么认出，告诉编译器里面是对象里边的成员变量

d1.year = year;

d2.year = year;

d3.year = year;

😺对象.成员-------就可以准确的把形参的值传到对应的对象的成员变量里边了

😺但是一个类可以创建多个对象，在使用对象的时候，我们不可能都去类里面写上他们的对象名，让编译器知道是哪个对象在引用，怎样才可以解决这一问题呢？

😺这时候this登场了！！！-------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(year + "/" + month + "/" + day);
    }


    public static void main(String[] args) {

// 构造三个日期类型的对象 d1 d2 d3 并对d1，d2，d3的日期设置
        Date d1 = new Date();
        d1.setDay(2020,9,15);
        
        Date d2 = new Date();
        d2.setDay(2020,9,16);
        
        Date d3 = new Date();
        d3.setDay(2020,9,17);
      
// 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }


}

---

四，构造方法

讲完对象的引用，我们可以更深入的了解一下对象，上面说到类就是相当于一个设计图一样的东西，只有被对象引用了，才是真正内存存在的东西，再没被引用前，是没有在内存开辟空间给类的

构造方法就是在对象引用的时候开辟空间给对象

我们再回头看看对象的引用

//通过new关键字实例化了一个对象
WashMachine wc = new WashMachine();

WashMachine类型的变量 wc = new 新的一个 WashMachine()方法；WashMachine()就是构造方法；

构造方法再new一个对象的时候就会被调用，编译器会自动给你提供一个不带参数的构造方法

但如果你自己重新定义了构造方法，编译器就会默认使用你的定义的构造方法，就不会再给你提供不带参数的构造方法

所以在你new了一个带参数的对象和一个不带参数的对象时，在你定义了一个带参数的构造方法的同时你必须也得定义一个不带蚕食得构造方法，否则编译器会报错

---

五，静态成员变量与方法

class student {
    public String name;
    public double score;
    public int age;
    public static String classes = "105java班";//静态成员变量，存储在方法区

    public student(String name, double score, int age) {
        this.name = name;
        this.score = score;
        this.age = age;
    }

在成员变量里边被static修饰得叫静态成员变量，也叫类变量，不需要new一个对象就可以直接使用，因为她存储在方法区，不属于所有得对象，是所有对象所共享的，

类似的，还有静态的成员方法

public static void staticFunc() {
        System.out.println("这是一个静态方法，类方法");

    }

静态的成员方法也叫类方法，不需要对象的引用，可直接通过类名访问，在静态的成员方法中可以直接访问静态的成员变量，但不能直接访问非静态的成员变量，

---

六 代码块

代码块有四种 普通代码块（本地代码块），实例代码块（构造代码块），静态代码块，同步代码块

---

七 内部类

总结 ：暂时写到这，持续更新中