Java面向对象（适合零基础小白入门教程9）

心已赠人 2023-10-06 15:26 11阅读 0赞

提纲：

1、面向对象
    2、类和对象
    3、方法的重载
    4、构造方法
    5、this关键字
    6、匿名对象
    7、作业

### **一、面向对象** ###

#### **1.1、生活中什么是面向对象** ####

洗衣服，吃饭
    面向过程：关注点是过程 ————站在一个执行者的角度去考虑事情，做事情
      //step1.找个盆
      //step2.收集要洗的衣服
      //step3.放水，放洗衣粉。。
      //step4：洗一洗
      //step5：晒一晒
    
    面向对象：关注点是对象 ————站在指挥者的角度
      //step1：找个对象
      //step2：让他洗衣服
      
      
    生活中的面向对象：找合适的人，做合适的事儿。。
    生活中的面向过程：亲力亲为，按照流程步骤来，一步一步，吭哧吭哧。。。
    
    代码中：
      Arrays类
        sort();-->排序
        binarySearch();-->搜索
      Scanner类
        sc.nextInt();
        sc.next();
        sc.nextDouble();

#### **1.2、面向对象和面向过程** ####

面向对象：(OOP)
      不是一种语言，而是一种编程思想。
      面向对象程序设计：(Object Oriented Programming)
        Object：对象
        Oriented：方向，定向
        Programming：程序
        
    面向过程：
      关注点在过程上(步骤)
      step1，step2，step3.。。。。
      总和分析，按照步骤实现即可。
    
    面向对象：
      关注点在对象上
        万事万物皆对象。
      A：分析当前的问题域中所涉及的对象。
      B：这些对象有什么样的特征和功能。
        外部特征：静态属性
        动作行为：动态属性
      C：对象和对象之间的关系。
        继承关系，聚合关系，关联关系。。。
        
        类的堆砌。

### **二、类和对象** ###

#### **2.1、类和对象** ####

![73a96286b6cc496d9627dc45da3b926a.png][]

类：其实指的就是类别。对同一类事物的统称。对这类事物进行描述，--->创建class
     就是一个抽象的概念。
    对象：
     类中的一个具体的实例，客观存在的，能用。个体。

如何定义一个类？

*  要有能够描述这一类别的外部特征——我们叫做属性(静态属性)  
    变量就可以。(名词)
 *  要有能够描述这一类别的行为功能——我们叫做方法(动态属性)  
    方法就可以。(动词)

#### **2.2、Java中定义类的格式** ####

/*
    class ClassName{//类名首字母大写
      //属性描述：外部特征
      //行为描述：能够干啥
    }
    */
    要求：
        1、CLassName要求符合驼峰命名法，首字母大写，见名知意。
        2、属性描述：外部特征，用于描述这个类别的一些特征，而这些特征通过一个"词"来描述清楚，比如姓名，年龄。使用变量来表示。——【成员变量】Field，词义"字段"
        3、行为描述：能够干啥，用于描述这个类别的一些行为功能，而这些行为功能，是一个动作行为，比如吃饭，睡觉。使用方法来表示。——【成员方法】Method，词义"方法"
          不要加static。

方法：就是一段具有独立功能的代码。

#### **2.2.1 step1声明类** ####

public class Person{//类的名字
    
    }

#### **2.2.2 step2声明类中的【成员变量】** ####

public class Person {
      //step2：成员变量
      String name;//使用String类型的变量name，表示人类中的姓名
      
      int age;//使用int类型的变量age，表示人类中的年龄
      
      char sex;//使用char类型的变量sex，表示人类中的性别
      
      
    }

#### **2.2.3 step3声明类中的【成员方法】** ####

public class Person {
      //step2：成员变量
      String name;//使用String类型的变量name，表示人类中的姓名
      
      int age;//使用int类型的变量age，表示人类中的年龄
      
      char sex;//使用char类型的变量sex，表示人类中的性别
      
      //step3：成员方法
      public void eat(){
        System.out.println("吃饭啦。。");
      }
      
      public void sleep(){
        System.out.println("睡觉啦。。");
      }
      
      public void daDouDou(){
        System.out.println("打豆豆。。。");
      }
    }

#### **2.3、类的对象** ####

#### **2.3.1 创建类的对象** ####

创建对象，也叫做类的实例化。对象，也叫类的实例。

/*
    new关键字
    new，词义：新的，新建
    new 关键字，专门用于新建对象。
    */
    Scanner sc = new Scanner();//Scanner也是个类，Person也是个类。
    int[] arr = new int[5];
    
    语法结构：
    /*
    类名 对象名 = new 类名();
    */
    Person p1 = new Person();

step2：根据类，实例化对象

step1：创建类

#### **2.3.2通过对象访问属性** ####

/*
    int[] arr = new int[5];
    获取数组的长度：
    arr.length
    arr的长度
    */
    对象访问属性的语法：就是一个.
    //给对象的属性，进行赋值
    p1.name = "王二狗";//给p1这个对象的name属性进行赋值
    p1.age = 18;
    p1.sex = '男';
    
    
    //获取对象的属性值
    System.out.println("姓名："+p1.name);
    System.out.println("年龄："+p1.age);
    System.out.println("性别："+p1.sex);

#### **2.3.3通过对象访问方法** ####

/*
    Scanner sc = new Scanner();
    sc.nextInt();
    */
    Scanner，就是一个class，一个类
    sc，是根据Scanner创建出来的一个对象
    
    对象调用类中的方法，语法，也是.
    对象.方法名();
    p1.eat();
    p1.sleep();
    p1.daDouDou();

#### **2.3 内存分析** ####

实例代码：

package com.qf.demo01;
    
    public class Test1Person {
    
      public static void main(String[] args) {
        //step1：创建Person类的对象
        //语法：类名 对象名 = new 类名();
        
        Person p1 = new Person();
        System.out.println(p1);//打印p1的值，p1是引用类型，打印都是p1指向的对象的地址。
        
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.sex);
        
        
        
        
        /*
         * com.qf.demo01.Person@15db9742
         * 包名.类名@编码值  ---->理解为p1的内存地址。
         * 
         * java中的数据类型：
         *  基本类型：byte，short，char，int，long，bolean，float，double
         *  引用类型：
         *      数组，类类类型
         * 
         */
        //step2：通过对象访问属性，语法是.
        //给对象的属性，进行赋值
        p1.name = "王二狗";//给p1这个对象的name属性进行赋值
        p1.age = 18;
        p1.sex = '男';
        
        
        //获取对象的属性值
        System.out.println("姓名："+p1.name);
        System.out.println("年龄："+p1.age);
        System.out.println("性别："+p1.sex);
        
        
        //step3：通过对象，访问成员方法--->理解为就是对象调用成员方法
        p1.eat();
        p1.sleep();
        p1.daDouDou();
        
        
      }
    
    }

内存分析图

![2e74598d08c249dc882c2f6b889480e4.png][]

示例代码：

package com.qf.demo01;
    
    public class Test2Person {
    
      public static void main(String[] args) {
        //1.创建一个Person类的对象
        Person p1 = new Person();
        System.out.println(p1);//p1的内存地址：com.qf.demo01.Person@15db9742
        
        p1.name = "张三狗";
        p1.age = 19;
        p1.sex = '男';
        
        System.out.println(p1.name);//张三狗
        System.out.println(p1.age);//19
        System.out.println(p1.sex);//男
              
        //2.再创建一个Person类的对象
        
        Person p2 = new Person();
        System.out.println(p2);//p2的内存地址，com.qf.demo01.Person@6d06d69c
        
        p2.name = "李小花";
        p2.age = 17;
        p2.sex = '女';
        
        System.out.println(p2.name);//李小花
        System.out.println(p2.age);//17
        System.out.println(p2.sex);//女
          
        //3.
        Person p3 = null;//仅仅声明了Person类型的对象p3，但是实际上，并没有在堆内存中，创建出真正的对象。
        
        /*
         * NullPointerException，空指针异常
         * 
         * 对象不存在，就是个null，
         *  强行的访问对象的属性或调用方法，就会空指针异常。
         */
        //System.out.println("---->"+p3.name);//报错啦：NullPointerException
        
        p3 = p1;//将p1的值（p1对象的内存地址），赋值给p3，结果-->p1和p3存储的是同一个对象的内存地址。
        
        p3.name = "李铁柱";
        System.out.println(p1.name);//李铁柱
        System.out.println(p2.name);//李小花
        System.out.println(p3.name);//李铁柱
        
        Person p4 = new Person();
        System.out.println(p4);//?
        
        p4.name = "王二丫";
        p4.age = 18;
        p4.sex = '女';
        System.out.println(p4.name );
        System.out.println(p4.age);
        System.out.println(p4.sex);
        
        p4 = p1;//改变对象的内存地址了，就不再指向原来的内存对象。
        System.out.println(p1.name);
        System.out.println(p3.name);
        System.out.println(p4.name);
      }
    
    }

内存分析图：

![ae28a6b9155b4aa6a18c8a4dae0498bd.png][]

#### **2.5、方法的重载：overload** ####

概念：一个类中的，一个功能方法的多种体现形式（有不同的方法体）。
    举例：
        1、人类，有吃的功能：eat()
                eat(食物);
                eat(药);
                eat(口香糖);
            
        2、求和的功能：
                getSum(int i,int j);
                getSum(double d1, double d2);
        3、水：
            常温：液态
            0度以下：固态
            100度以上：气态
            
    就是同一个功能的方法，因为参数的不同，调用的具体的方法也不同。
    如何判定多个方法是否是重载的？衡量标准，要同时满足以下三条：
        A：必须同一个类中。
        B：方法名称必须一致。
        C：参数列表必须不同。（顺序，个数，类型）
        
            和static，public，返回值，void等等都没有关系。
    优点：
        1、简化了开发的压力
        2、简化了记忆的压力
        3、调用方法更方便，更简洁，又满足了不同的情况
            
    基本原理：
        当方法名称一致时，通过形式参数列表的不同来选择要执行的方法。

示例代码：

package com.qf.demo01.overload;
    
    import java.util.Arrays;
    
    /*
     * 方法的重载：
     * 同一个功能：
     *  根据参数的不同，执行的具体的方法也不同
     * 
     * 衡量方法是否重载：
     *  1、同一个类中
     *  2、方法名必须一致
     *  3、参数列表必须不同：类型，个数，顺序
     */
    public class Test1 {
      //求两个数的和：
      
      //求两个整数的和
      public static void getSum(int i,int j){
        int sum = i + j;
        System.out.println(i+" + " + j +"的总和是："+sum);
      }
      
      public static void getSum(double d1, double d2){
        double sum = d1 + d2;
        System.out.println("总和是："+sum);
      }
      
      
      public static void getSum(int i,double j){
        
      }
      
      public static void getSum(double d1,int i1){
        
      }
    
      public static void main(String[] args) {
        getSum(1, 2);
        
        getSum(3.14, 4.21);
    
        
      }
      
      
    }

#### **2.6、构造方法** ####

构造方法：是一个很特殊的方法。

*  声明的语法：public 类名()\{\}
    
     *  修饰符：只能有访问权限的修饰符，public。不能加static。
     *  返回值：没有返回值，也不能写void。
     *  方法名：必须和类名相同
 *  调用的方式：new 关键字调用
    
     *  new关键字后面跟着构造方法即可。
 *  作用：专门用于创建对象。

普通方法：一段具有特殊功能的代码。而且可以被多次调用执行。

*  声明的语法：public static void main(String\[\] args)\{\}
 *  调用的方式：方法名(实参)；
 *  作用：1、避免重复的代码增强程序的可读性。2、提高程序的可维护性。

1、编写java的源代码(给人看)：XXX.java
    2、将源文件进行编译(机器执行的就是这个字节码文件)：XXX.class
      javac命令  javac XXX.java
    3、JVM执行字节码文件：XXX.class
      java命令  java XXX
    
    Java反编译工具：我们现在将class文件，进行反编译，可以看见类似于底层语言
      javap -c -l -private XXX.class

#### **2.6.1 Java编译器提供的默认的构造方法** ####

问题：创建对象的时候，代码：new Person();调用的这个Person()这个方法，在程序中并没有写，哪来的？
    
    试着将Person.class文件进行反编译：

![c37be4092caa4deb9497160b22d16d0b.png][]

结论：通过反编译工具，发现了一些和源代码不相符的内容，这就是javac编译器，自动给代码中添加的构造方法。用于创建对象。

java编译器，发现代码中没有任何的构造方法，在编译时，会自动的帮我们添加一个无参的构造方法。

如果代码中自己写了构造方法，那么编译器不再帮我们添加无参的构造方法。

####    **2.6.2 自定义的构造方法** ####

记住一条：如果一个类中，没有写任何的构造方法，那么编译器自动添加一个无参的构造方法。但是如果你写了构造方法，那么编译器不再添加了。
    我们写程序的规则：
      无参构造要写
      有参构造看实际情况
      一个类中可以有多个构造方法的。也是方法的重载。
      
    创建对象的语法：
      new 构造方法(可能有参数);
      
    如果添加自己定义的构造方法：
    语法规则：
    public 类名(){
    
    }
    public 类名(参数列表){
      将参数的数值，赋值给属性即可。
    }

如何创建一个对象？就是通过new这个关键字，调用一个类的构造方法。就创建了对象。

先声明，再调用--->普通方法，还适合构造方法。

如果一个类中，没有手动的写一个构造方法的话，那么编译器会自动的添加一个无参的构造方法。

示例代码：

class Person{
      String name;
      int age;
        public Person(){//无参的构造方法
            
        }
        public Person(String n,int a){//有参的构造方法
            name = n;
            age = a;
        }
    }
    class Test{
        public static void main(String[] args){
            Person p1 = new Person();
            p1.name = "李小花";
            p1.age = 18;
            
            Person p2 = new Person("王二狗",18);
        }
    }

注意点：

> 1、如果代码中，没有写构造方法。编译器会自动的添加一个无参的构造方法。  
> 2、如果代码中，写了构造方法。编译器都不会再给我们添加无参的构造方法。编码习惯：写了有参构造，再写上无参构造。

对比一下构造方法和普通方法：

![37edc09833c04169991acb9ecf61f6b6.png][]

#### **2.7、this关键字** ####

词义：这个。

#### **2.7.1 就近原则问题** ####

当写代码的时候，要给成员变量，参数，局部变量等等，要进行命名。根据见名知意的原则，很容易就命名冲突了。
    在程序当中，有个就近原则，一旦名字冲突，就要看离哪个声明近。
    导致名称中成员变量和局部变量的命名冲突！！！
    public Person(String name,int age){//name="李小花"
        name = name; //=两侧的name，都是指参数
        age = age;
    }
    因为命名规范，见名知意，成员变量和局部变量，命名相同了。
    因为就近原则问题：构造方法Person中，name和age，都会看成了这个参数，就是局部变量。
        
    希望有一种方式，来告诉编译器：=左边的是成员变量，=右边的才是参数。
      可以借助于this这个关键字解决。

#### **2.7.2 this的用法一** ####

表示当前对象。

this.属性，没有this的就是局部变量。可以解决命名冲突的问题。
    public Person(String name,int age){//name="李小花"
        this.name = name; //=左侧的是this的name属性
        this.age = age;
    }
    使用this关键字，明确的告诉编译器，this后的这个name，就是成员变量。对象的属性。没有this的就是参数。
        解决成员变量和局部变量的命名冲突。
          this点的就是成员变量，没有this的就是局部变量。

示例代码：

package com.qf.demo03;
    
    public class Person {
      //成员变量
      String name;//属性，成员变量，人有姓名
      int age;
      
      public Person(){
        
      }
      
      /*
       * 就近原则：成员变量和局部变量命名冲突了。方法中name默认都是参数。
       */
      public Person(String name,int age){//name="李小花"
        this.name = name; 
        this.age = age;
      }
      
      public void eat(){
        System.out.println(name+",吃东西啦。。");
      }
      
      //this，当前的对象。谁调用谁就是当前的对象
      //当p1调用的时候，this就指代p1
      //当p2调用的时候，shis就指代p2
      
      
      //在类中提供一个功能：成员方法
      public void showInfo(){
        System.out.println("姓名："+this.name+",年龄："+age);
      }
    }

#### **2.7.3 this的用法二** ####

this()指代当前类的构造方法。

this(参数)，就表示的构造方法。
    如果一个类中，有多个构造方法，之间存在了调用关系，那么使用this()来指代这个构造方法。具体指代哪个构造方法，要靠参数来区分。
    注意点：当this()指代构造方法，那么必须放在首行。

示例代码：

package com.qf.demo03;
    
    public class Student {
      String name;
      int age;
      String sex;
      double score;
      
      public Student(){
        System.out.println("无参的构造方法，Student()...");
      }
      
      
      public Student(String name,int age){//给name和age属性赋值
        System.out.println("有参构造方法。。2个参数。。");
        this.name = name;
        this.age = age ;
      }
      
      public Student(String name,int age,String sex,double score){
        this(name,age);//this()，指代构造方法。
        System.out.println("有参构造方法。。4个参数。。");
    //    this.name = name;
    //    this.age = age;
        this.sex = sex;
        this.score = score;
      }
      
      public void showInfo(){
        System.out.println("姓名："+name+",年龄："+age+",性别："+sex+",成绩："+score);
      }
    }

#### **2.8、匿名对象** ####

创建对象的语法：
        Person p1 = new Person();
        //=左侧在做对象的声明，开辟的是栈内存
        //=右侧，才是真正的创建对象
        //结果：内存中，创建了一个对象，对象的地址，赋值给p1。
    匿名对象，就是只有=右侧，没有=左侧。
        new 构造方法(必要的参数);
    匿名对象的用途：
        1、使用匿名对象，直接调用类的方法。
        2、匿名对象直接作为一个方法的参数。
        
    注意点：
        匿名对象只能使用一次。随着它的创建而使用一次。（一次性的）
    优势：
        1、使用后即销毁，就是被GC回收。
        2、代码书写方法，提高效率。

示例代码：

package com.qf.demo01;
    
    public class Test1 {
    
      public static void main(String[] args) {
        //创建正常的对象，有引用，有对象
        Person p1 = new Person();
        
        //通过p1，来指挥对象：可以访问属性，赋值，取值，，可以调用方法
        p1.name = "王二狗";
        p1.age = 19;
        System.out.println(p1.name);
        System.out.println(p1.age);
        
        p1.eat();
        p1.eat();
        
        
        
        //创建一个匿名对象，没有栈的引用，只有堆中的对象。
        //局限：只能使用一次，创建的时候使用一次。
        new Person().eat();
        new Person("李小花",18).eat();
        
        
        //只有=左侧
        Person p2 = null;//只有对象声明
        p2.eat();
        
      }
    
    }

### **三、作业** ###

1.this关键字的用法写3遍，记下来.
    2.创建一个Teacher类。设置属性和方法。无参构造方法和有参构造方法。并创建对象，打印对象的属性信息。执行成员方法。
    
    3.创建一个Computer类,设置该类的属性,以及一个方法,用于显示计算机的属性信息.并添加构造方法,无参的和有参的.分别创建该类的对象.执行方法.
    
    4.创建一个Girl类,设置属性name,age,无参构造和有参构造.创建该类对象,为属性赋值.打印属性值.
    5.（选做）设计一个学生类，有姓名，有年龄，有性别，有英语成绩，数学成绩，语文成绩，提供无参构造和有参构造
    
      设计方法，求总分，平均分，以及打印学生的信息。3个对象。

[73a96286b6cc496d9627dc45da3b926a.png]: https://img-blog.csdnimg.cn/73a96286b6cc496d9627dc45da3b926a.png
[2e74598d08c249dc882c2f6b889480e4.png]: https://img-blog.csdnimg.cn/2e74598d08c249dc882c2f6b889480e4.png
[ae28a6b9155b4aa6a18c8a4dae0498bd.png]: https://img-blog.csdnimg.cn/ae28a6b9155b4aa6a18c8a4dae0498bd.png
[c37be4092caa4deb9497160b22d16d0b.png]: https://img-blog.csdnimg.cn/c37be4092caa4deb9497160b22d16d0b.png
[37edc09833c04169991acb9ecf61f6b6.png]: https://img-blog.csdnimg.cn/37edc09833c04169991acb9ecf61f6b6.png