二、面向对象中方法与类之间的调用(2022.4.20)

面向对象(OOP)

一、初识面向对象

• 面向对象&面向过程
  • 步骤简单清晰，第一步做什么、第二步做什么…
  • 面向过程适合处理一些较为简单的问题
• 面向对象思想
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要的那些分类，然后对这些分类进行单独思考；最后，才对某个分类下的细节进行面向过程的思索。
  • 面向的对象适合处理复杂的问题，适合处理需要多人协作的问题！
• 对于描述复杂的十五，为了从宏观上把握、从整体上合理的分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
• 面向对象编程(Object-Oriented Programming,OOP)
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
• 抽象
• 三大特性：
  • 封装
  • 继承
  • 多态
• 从认识论角考虑是先有对象后有类；对象：是具体的事物；类：是抽象的，是对对象的抽象.
• 从代码运行角度考虑是先有类后有对象；类是对象的模板。

对象传参：

    package com.oop;
    public class Demo1 {
        public static void main(String[] args) {
            String s = Demo1.sayHello("只要持之以恒，即使再小的船也能远航！");   
          // 这边给它传入一个实际参数并且参数类型为String
            System.out.println(s);  // 输出
        }
        public static String sayHello(String a){   // 这边定义一个返回值为String的方法以及传入一个形参类型也为String
            return a;    // 返回当前参数值
        }
        public  void say(){
            System.out.println("冰冻三尺非一日之寒！");
        }
    }
    输出：
    	只要持之以恒，即使再小的船也能远航！

类与类之间使用对象进行调用

    package com.oop;
    public class Demo2 {
        public static void main(String[] args) {
            Demo1 demo1 = new Demo1();  // 实例化
            demo1.say();   // 使用对象.方法名就可以进行调用
        }
    }
    输出：
    	冰冻三尺非一日之寒！

使用return进行返回结果集

    package com.oop;
    public class Demo3 {
        public static void main(String[] args) {
            int a = Demo3.A(1, 2);    // 进行传入参数(实参)
            System.out.println(a);    // 进行输出
        }
        public static int A(int a,int b){  // 定义的方法带返回结果并且定义两个形参
          return a+b;   // 返回这两个数字的操作
        }
    }
    输出：
    	3

在不同类之间的调用以及返回

    package com.oop;
    public class Demo4 {
        public static void main(String[] args) {
            int a = 100;      
            System.out.println(a);
            Student.A(a);
            System.out.println(a);
    
            int b = Return.B(a);
            System.out.println(b);
            String name = "张三";
            String c = Return1.C(name);
            System.out.println(c);
        }
    }
    class Student{
        public static void A(int a){
            a = 10;
        }
    }
    class Return{
        public static int B(int a){
            return a = 20;
        }
    }
    class Return1{
        public static String C(String b){
            String name;
            return b;
        }
    }
    输出：
    	100    // 正常输出，没问题
      	100    // 没有return的时候不能进行第二次赋值的操作
    	20    // return之后可以成功赋值(值传递)
    	张三   // 也可以进行引用传递，因为定义的返回值类型为String并且用String进行接收(引用传递)

解析：如果不进行return返回话，那么不管怎么操作都是无意义的，然而，如果你编写了有返回值的方法，并且定义形参以及传入实参时，这时候你的操作就可以输出，从而体现return的作用。引用传递的本质也是值传递。

注意：一旦定义有返回值的方法时就需要拿对应的类型来进行接收，就可以输出.

1、类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物真题描述/定义，但是不能代表某一个具体的事物。
  • 动物、植物、手机、电脑…
  • Preson类、Pet、Car类等，这些类都是用来描述/定义某一类的具体的事物应该具备的特点和行为。
• 对象是抽象概念的具体实例
  • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例…
  • 能够体现出特点，展现功能的是具体的实例，而不是一个抽象的概念.

2、创建与初始化对象

• 使用new关键字创建对象.
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器进行调用。
• 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的；并且构造器有一下两个特点：
  • 1、必须和类的名字相同；
  • 2、必须没有返回类型，也不能写void.
• 构造器必须要掌握.

使用：

    package com.oop1;
    /*
           学生类
     */
    public class Student {
        // 属性
        String name;
        int age;
        String sex;
        int money;
        // 方法
        public void study(){
            System.out.println(this.name+this.age+sex+money);
        }
    }
    package com.oop1;
    public class Application {
        // 主测试方法
        public static void main(String[] args) {
            Student student = new Student();
            student.name="张三";
            student.age=19;
            student.sex="男";
            student.money=1000000000;
            System.out.println("姓名："+student.name+" "+"年龄："+student.age+" "+"性别："+student.sex+" "+"存款："+student.money+"万元");
            Student student1 = new Student();
            student1.name = "李四";
            student1.age = 20;
            student1.sex = "男";
            student1.money=1;
            System.out.println("姓名："+student1.name+" "+"年龄："+student1.age+" "+"性别："+student1.sex+" "+"存款："+student1.money+"块");
        }
    }
    输出：
          姓名：张三 年龄：19 性别：男 存款：1000000000万元
          姓名：李四 年龄：20 性别：男 存款：1块

注意：在Java类中一个类可以new无数次并且每new一次分配的内存都是独立的，第一个new的对象赋的值不会影响第二次new的对象。