【Java】类和对象

06-02 1291阅读

【Java】类和对象

🎁个人主页:User_芊芊君子

🎉欢迎大家点赞👍评论📝收藏⭐文章

🔍系列专栏:【Java】内容概括

【Java】类和对象

【Java】类和对象

【前言】

在Java编程的世界里,类(Class)和对象(Object)是面向对象编程(OOP,Object-Oriented Programming)的核心概念。理解它们不仅是掌握Java语言的关键,更是构建大型、可维护软件系统的基础。本文将详细介绍Java类和对象,通过理论结合代码示例,帮助大家深入理解这两个重要概念。

文章目录:

  • 一、面向对象
    • 1. 什么是面向对象
    • 2. 面向对象和面向过程
    • 二、类的定义和使用
      • 1. 什么是类
      • 2.类的定义格式
      • 三、类的实例化
        • 1.什么是类的实例化
        • 2. 访问对象中的成员
        • 四、this 关键字
          • 1. this 是什么?
          • 2. this 的特性
          • 五、对象的构造及初始化
            • 1.初始化对象中的成员变量
            • 2. 就地初始化
            • 3.构造方法初始化
              • 1.什么是构造方法
              • 2.注意事项
              • 六、对象的打印

                一、面向对象

                1. 什么是面向对象

                Java是⼀⻔纯⾯向对象的语⾔(Object Oriented Program,简称OOP),在⾯向对象的世界⾥,⼀切皆为对象。⾯向对象是解决问题的⼀种思想,主要依靠对象之间的交互完成⼀件事情。⽤⾯向对象的思想来设计程序,更符合⼈们对事物的认知,对于⼤型程序的设计、扩展以及维护都⾮常友好。

                2. 面向对象和面向过程

                这里用一个形象的例子来解释一下

                eg:

                传统洗衣服的过程:

                • 放水
                • 放衣服
                • 放洗衣粉
                • 手搓
                • 换水
                • 漂洗
                • 拧干
                • 晾晒

                  洗衣机洗衣服:

                  • 放衣服
                  • 放洗衣液

                    这里洗衣机就是面向对象,我们不需要关注过程,只需要放入衣服,洗衣液后,启动开关就行了,这就是通过对象之间的交互完成的.

                    注意:⾯向过程和⾯向对象并不是⼀⻔语⾔,⽽是解决问题的⽅法,没有那个好坏之分,都有其专⻔ 的应⽤场景。

                    二、类的定义和使用

                    1. 什么是类

                    类是一种抽象的数据类型,它是对具有相同属性和行为的对象的抽象描述。简单来说,类定义了对象的状态(属性)和行为(方法)。

                    eg:定义一个类“汽车”

                    属性:

                    • 品牌
                    • 款式
                    • 颜色
                    • 速度

                      行为:

                      • 启动
                      • 加速
                      • 刹车
                      • 倒车

                        2.类的定义格式

                        //创建类
                        calss ClassName{
                          field;  //字段(属性) 或者 成员变量
                          method; //⾏为 或者 成员⽅法
                          }
                        
                        • class : 类的关键字
                        • ClassName :类的名字
                        • { }中:类的主体

                          创建一个“汽车”类

                          public class CompactCar {
                              public String brand;//品牌
                              public String style;//款式
                              public String color;//颜色
                              public String speed;//速度
                              public void startCar(){
                                  System.out.println("启动");
                              }
                              public void speedCar(){
                                  System.out.println("加速");
                              }
                              public void brakeCar(){
                                  System.out.println("刹车");
                              }
                              public void backCar(){
                                  System.out.println("倒车");
                              }
                          }
                          

                          采⽤Java语⾔将“汽车”类在计算机中定义完成,经过javac编译之后形成.class⽂件,在JVM的基础上计算机就可以识别了。

                          注意:

                          • 类名使用大驼峰定义
                          • 成员前写法统一为public
                          • 这里的方法不到static关键字

                            如果要改类名,看下面这个步骤:

                            【Java】类和对象

                            【Java】类和对象

                            三、类的实例化

                            1.什么是类的实例化

                            我们定义了一个类,就是在计算机中定义了一种新的类型,它与Java语言中自带的内置类型(eg:int , double …)类似,区别就是类是新定义出来的,比如我们上面定义的“汽车”类,定义好类后,就可以使用类来定义实例(对象)

                            **实例化就是用类类型创建对象的过程**在java中采⽤new关键字,配合类名来实例化对象。

                            public class PetDog {
                                public static void main(String[] args) {
                                    PetDog dog = new PetDog();
                                }
                            }
                            

                            2. 访问对象中的成员

                            public class PetDog {
                                public String name;
                                public int age;
                                public static void main(String[] args) {
                                    PetDog dog = new PetDog();//实例化
                                    dog.name = "大黄";
                                    dog.age = 2;
                                    System.out.println("name:"+dog.name);
                                    System.out.println("age:"+dog.age);
                                }
                            }
                            

                            【Java】类和对象

                            注意事项

                            • new 关键字⽤于创建⼀个对象的实例.
                            • 使⽤.来访问对象中的属性和⽅法.
                            • 同⼀个类可以创建多个实例.

                              四、this 关键字

                              如下代码定义了⼀个Date类,Date类中包含3个属性分别是year,month,day。分别使⽤ setDay 和 printDate 对进⾏设置和打印⽇期。

                              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) {
                                      Date d1 = new Date();
                                      d1.setDay(2025,3,30);
                                      d1.printDate();
                                  }
                              }
                              

                              【Java】类和对象

                              现在有两个问题:

                              • 形参名相同会怎样?

                                【Java】类和对象

                                • 当有两个对象时,函数执行哪个对象的数据呢?
                                   public void setDay(int y,int m,int d){
                                          year = year;
                                          month = month;
                                          day = day;
                                      }
                                      //这里变成了形参自己对自己赋值
                                  

                                  这个时候就要用到 this

                                  1. 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) {
                                          Date d1 = new Date();
                                          d1.setDay(2025,3,30);
                                          d1.printDate();
                                          Date d2 = new Date();
                                          d2.setDay(2024,3,30);
                                          d2.printDate();
                                      }
                                  }
                                  

                                  【Java】类和对象

                                  此时通过指定this,就能正确解决上述的2个问题了。这⾥之所以可以起作⽤,关键点在于this代表的是当前对象的引⽤,当前对象就是指:哪个对象调⽤setDay⽅法,谁就是this引⽤!

                                  2. this 的特性

                                  • this的类型:对应类类型引⽤,即哪个对象调⽤就是哪个对象的引⽤类型
                                  • this只能在"成员⽅法"中使⽤
                                  • this是“成员⽅法”第⼀个隐藏的参数,编译器会⾃动传递,在成员⽅法执⾏时,编译器会负责将调⽤成员⽅法对象的引⽤传递给该成员⽅法,this负责来接收
                                  • this的使⽤

                                    this.成员变量; this.成员方法;

                                    五、对象的构造及初始化

                                    1.初始化对象中的成员变量

                                    我们都知道局部变量必须初始化,否则就会报错,但在这里,没有对成员变量进行初始,并没有报错,因为他们默认初始化了

                                    对于成员变量来说,如果没有进⾏初始化,会有⼀个对应的默认值,默认值遵循如下规则:

                                    【Java】类和对象

                                    2. 就地初始化

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

                                    public class Date {
                                        public int year = 2021;
                                        public int month = 8;
                                        public int day = 9;
                                        public void setDay(int year,int month,int day){
                                            this.year = year;
                                            this.month = month;
                                            this.day = day;
                                        }
                                    }
                                    

                                    3.构造方法初始化

                                    1.什么是构造方法

                                    构造⽅法(也称为构造器)是⼀个特殊的成员⽅法,名字必须与类名相同,在创建对象时,由编译器⾃动

                                    调⽤,并且在整个对象的⽣命周期内只调⽤⼀次。

                                    public class Person {
                                        public String name;
                                        public int age;
                                        public Person(String name,int age){
                                            this.name = name;
                                            this.age = age;
                                            System.out.println("带两个参数的构造方法被调用了");
                                        }
                                        public Person(){
                                            this.name = "baby";
                                            this.age = 10;
                                            System.out.println("不带参数的构造方法被调用");
                                        }
                                        public void sleep(){
                                            System.out.println(this.name+"正在睡觉");
                                        }
                                        public void eat(){
                                            System.out.println(this.name+"正在吃饭");
                                        }
                                    }
                                    
                                    public class Test {
                                        public static void main(String[] args) {
                                            Person person = new Person("baby",18);
                                            Person person1 = new Person();
                                        }
                                    }
                                    

                                    【Java】类和对象

                                    2.注意事项

                                    • 名字必须与类名相同
                                    • 没有返回值类型,设置为void也不⾏
                                    • 创建对象时由编译器⾃动调⽤,并且在对象的⽣命周期内只调⽤⼀次(相当于⼈的出⽣,每个⼈只能 出⽣⼀次)
                                    • 构造⽅法可以重载,如下:

                                      (名字相同,参数列表不同,因此构成了⽅法重载。)

                                      public class Date {
                                      public int year;
                                      public int month;
                                      public int day;
                                      // ⽆参构造⽅法
                                      public Date(){
                                      this.year = 1900;
                                      this.month = 1;
                                      this.day = 1;
                                      }
                                      // 带有三个参数的构造⽅法
                                      public Date(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) {
                                      Date d = new Date();
                                      d.printDate();
                                      }
                                      
                                      • 如果⽤⼾没有显式定义,编译器会⽣成⼀份默认的构造⽅法,⽣成的默认构造⽅法⼀定是⽆参的。

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

                                        此时如果调用不带参数的构造方法,就会报错

                                      • 构造⽅法中,可以通过this调⽤其他构造⽅法来简化代码(this(…)必须是构造⽅法中第⼀条语句)

                                        public class Date {
                                              public int year;
                                              public int month;
                                              public int day;
                                        public Date(){
                                            this(1900, 1, 1);
                                         }
                                        // 带有三个参数的构造⽅法
                                        public Date(int year, int month, int day) {
                                             this.year = year;
                                             this.month = month;
                                             this.day = day;
                                           }
                                         }
                                        

                                        六、对象的打印

                                        如果属性太多,就不便使用方法进行打印,这时候可以重写toString

                                        public class Person {
                                            public String name;
                                            public int age;
                                            public Person(){
                                                this.age = 10;
                                                this.name = "baby";
                                            }
                                            @Override
                                            public String toString() {
                                                return "Person{" +
                                                        "name='" + name + '\'' +
                                                        ", age=" + age +
                                                        '}';
                                            }
                                            public static void main(String[] args) {
                                                Person person = new Person();
                                                System.out.println(person);
                                            }
                                        }
                                        

                                        这里是快捷添加方式:

                                        【Java】类和对象

                                        【Java】类和对象

                                        【Java】类和对象

                                        【Java】类和对象

                                        执行结果:

                                        【Java】类和对象

                                        【总结】

                                        本文详细介绍了Java类和对象的基本概念、定义和使用方法,以及构造方法等重要特性。理解类和对象是掌握Java面向对象编程的基础,希望通过本文的介绍,大家对Java类和对象有更深入的理解。通过这篇文章,希望能帮助你在Java的学习道路上更上一层楼,掌握面向对象编程的精髓。

                                        【Java】类和对象

免责声明:我们致力于保护作者版权,注重分享,被刊用文章因无法核实真实出处,未能及时与作者取得联系,或有版权异议的,请联系管理员,我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明:本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度,360,搜狗等多加搜索引擎自动关键词搜索配图,如有侵权的图片,请第一时间联系我们。

相关阅读

目录[+]

取消
微信二维码
微信二维码
支付宝二维码