2022-07-18 第七组姜珊学习笔记

java 面向对象

1.Java是一门面向对象的编程语言。在java中，万事万物皆对象（在Linux中，万事万物皆文件）

面向过程和面向对象

面向过程：

​ 面向过程就是分析出实现需求需要的步骤，通过一些方法一步一步实现。

面向对象（行为化）：

​ 把整个需求的按照特点、功能划分，将这些存在共性的部分封装成类（类实例化之后才是对象），让对象去解决问题。
​ 高级的编程语言，会向着人的思考靠近。面向对象更高级的抽象，是对现实世界的映射。

在Java中，面向对象有3大特征：

1、封装

2、继承

3、多态

4、抽象

以开4s店为例；造汽车

package com.jsoft.morning;

/**
 * 我们要造车了，必须有一个图纸
 * 根据图纸，可以造一百台车
 * 这个图纸就是在描述车的具体信息，对车的信息的封装。
 *
 * 我个人的理解：
 * 封装：1、代码层面    2、思想层面
 *
 * 如果把变量直接声明在类里：成员变量（全局变量）
 * 如果把变量声明在某个方法里：局部变量
 *
 * 成员变量->属性
 */
public class Car {

    // 车的品牌
    // 只声明，不赋值。
    String brand;
    // 车的颜色
    String color;
    // 车的长度
    long length;
    /*
        我们的造车的图纸就画完了。
        这个类，描述汽车属性的类。

        我们现在有了图纸，要去造车，怎么造车。
     */
    /**
     * 定义一个成员方法
     * 跑的方法
     *
     * 
    public void run(int gasoline,String tire){
        // 中间省略了打火，挂挡
        if(gasoline == 92){
            System.out.println("92号汽油跑的很快！");
            return;
        }else if(gasoline == 95){
            System.out.println("95号汽油跑的更猛");
        }else {
            System.out.println("你加了假油吧？");
        }
        System.out.println(brand + "在漂移！");
    }

    
    public boolean run(int gasoline){
        if(gasoline == 92){
            System.out.println("92号汽油跑的很快！");
            return true;
        }else if(gasoline == 95){
            System.out.println("95号汽油跑的更猛");
            return true;
        }else {
            System.out.println("你加了假油吧？");
            return false;
        }
    }
    public void show(){
        run(95);
    }   
}

public：访问权限修饰符，

void：没有返回值
run()：方法名，标识符

{}：方法体。这个方法要干什么
()：传参数
在声明方法时，括号里的参数，形式参数，形参，可以当做局部变量使用
在调用方法时，真正传入方法的参数，实际参数，实参。
参数可以有多个，中间用逗号隔开 Java中的传参，需要明确数据类型
标识符的命名规则：字母，数字，下划线，美元符号，数字不能开头
1、类名：大驼峰

2、属性名、方法名：小驼峰

访问权限修饰符：
public：公有的，公共的。最大，只要是public声明的方法，只要在同一个工程中，都能用。
protected：受保护的
默认的：友好的
private：私有的，最小。只有在当前类可以用。

ackage com.jsoft.morning;

public class Ch02 {

    public static void main(String[] args) {
        // 创建了一个Ch02这个类的对象，c
        Ch02 c = new Ch02();
        // 根据图纸去造车
        // 创建对象的过程，类的实例化的过程，对象又叫做类的一个实例
        // 我们创建了一个Car类的对象car1
        // 这个car1就是对象的名
        // 其实这个car1就是个标识符
        // 对象名的命名规则：小驼峰
        // 创建对象的语法：类名 对象名 = new 类名();
        Car car1 = new Car();
        // 给车的属性赋值
        car1.brand = "奥迪";
        car1.color = "白色";
        car1.length = 5L;
        // 取出属性的值
        System.out.println("生产了第1台汽车，它的属性为：" + car1.brand + "，" + car1.color + "，" + car1.length + "米");
        System.out.println(car1);

        Car car2 = new Car();
        car2.brand = "丰田";
        car2.color = "灰色";
        car2.length = 4L;

        System.out.println("生产了第2台汽车，它的属性为：" + car2.brand + "，" + car2.color + "，" + car2.length + "米");

        /*
            car1和car2都是Car类的一个实例（对象）
            每一个对象之间
            但是他们之间是相互隔离的。

            Car是类，只有一份。
            car1,car2.....car100是根据类构建出来的【实例对象】，可以有很多个，而且他们可能都不一样。

         */
    }
}

划重点：

• 1、之前我们学习过8种基本数据类型

• 2、从今天开始数据类型就更多了。我们能够遇见的所有的类，

• 包括我们刚刚创建的Car是一种数据类型，一个美女也是一个数据类型。

• 所有的类都是数据类型，都是引用数据类型。

• 此刻起，我们才真正了解了class这个关键字，创建一个类，用来创建一个数据类型。

• 像car1,car2,car3....car100叫引用，它是指向内存中的一块区域。存放这些对象的空间，我们叫做堆。

• 我们需要了解两块内存空间：

• 1、栈：变量，基本数据类型

• 2、堆

• 引用数据类型的初始值为null

• package com.jsoft.morning;
  
  import java.util.Scanner;
  
  
   * 成员方法：（JS里的函数）
   *
   * 一个汽车只有颜色、品牌这些属性，它就是一块废铁。
   * 开车实际上是一个动作（行为），没有办法再通过属性去描述。
   * 需要一步一步去做到行为。
   *
   * 到底什么时候要有返回值，什么时候没有返回值？
   * 开发中，大部分的方法有返回值的。
  public class Ch04 {
  
      public static void main(String[] args) {
  //        Scanner sc = new Scanner(System.in);
  //        String flag = sc.next();
  
  
          Car car1 = new Car();
          // 对象.属性名
          car1.brand = "大众";
          car1.color = "黑色";
          car1.length = 6L;
  
  //        return;
          // 对象.方法名
  //        car1.run(95,"锦湖轮胎");
          // 有返回值的方法在执行后会得到一个具体的值，这个值可以存下来的
          boolean result = car1.run(12);
          System.out.println(result);
      }
  }
  

成员方法

• 1.方法名不能重复

• 自己调自己-递归

• 递归的问题：StackOverflowError 栈溢出 内存溢出

  斐波那契数列

public class Ch01 {
        我们知道除了0和1，第number个数字
        等于第number-1个数和第number-2个数的和

        当number = 4;
        return fibonacci(3) + fibonacci(2);
        fibonacci(3) = fibonacci(2) + fibonacci(1)
        fibonacci(2) = fibonacci(1) + fibonacci(0)
     */
    public int fibonacci(int number){
        if(number == 0 || number == 1){
            return number;
        }else {
            return fibonacci(number - 1) + fibonacci(number - 2);
        }
//        int result = 0;
//        for (int i = 0; i < number; i++) {
//
//            result = (number - 1) + (number - 2);
//        }
    }

    public int factorial(int number) {
        // 5! = 5 * 4 * 3 * 2 * 1
        // 循环的做法
//        int result = 1;
//        for (int i = 1; i <= number ; i++) {
//            result *= i;
//        }
        if(number <= 1){
            return 1;
        }
        return number * factorial(number - 1);
    }

main方法 主方法
如果一个方法有static
要调用一个非static的方法
就只能创建对象，使用对象.方法的形式调用

方法的重载（Overload）

• 1.方法名相同

• 2.参数不同（参数的类型，参数的个数，参数的顺序）

• 3.发生在同一个类里

• 与返回值类型无关，与访问权限修饰符无关，与方法体无关

• 方法的重载的好处：

• 为了把功能相似相同的方法用同一个名字

• ublic class Ch02 {
  
  //    public int sum(int num1,int num2){
  //
  //        return num1 - num2;
  //    }
  
      public void sum(int num1,int num2) {
          System.out.println(num1 + num2);
      }
  
      public void sum(int num1,int num2,int num3){
          System.out.println(num1 + num2 + num3);
      }
  
      public void sum(double d1,double d2) {
          System.out.println(d1 + d2);
      }
  
      public void sum(int num1,double d2){
          System.out.println(num1 + d2);
      }
  //    public void sum(double d1,int num1){
  //
  //    }
  
  //    public void sum(double d2,int num2){
  //
  //    }
  
      public void sum(double d1,double d2,double d3){
          System.out.println(d1 + d2 + d3);
      }
  
      public static void main(String[] args) {
          Ch02 c = new Ch02();
          c.sum(1,2);
      }
  }
  

访问权限：

• public：一个工程下任意位置都可以访问
• 类，属性上，方法上，构造器
• protected：可以跨包，如果跨包，必须是他的子类
• 属性，方法，构造器
• (默认的)：当前包下可以访问
• 类，属性，方法，构造器
• private：只有当前类可以访问
• 属性，方法，构造器

构造器（构造方法）

• 语法：

• 访问权限修饰符 类名(参数列表){
  *

• }

• 特点：

• 1.java在new对象的时候，先看对象所对应的类有没有构造器，有什么样的构造器。

• 如果没有构造器，则无法创建对象

• 2.每个类会有一个默认的无参的构造器

• 3.在对象被实例化时，调用了构造器

• 4.我们创建对象实际上是通过构造器创建的

• 5.如果一个类中显式的声明了一个构造器，原来默认自带的无参构造器就失效
  今日学习重点
  面向过程和面向对象：理解
  定义方法：理解
  构造器：不太理解用法
  访问权限：理解

  今日学习心得，

  知识有点没吸收，方法理解，构造器运用不太理解，不明白什么位置，那里用构造器，对什么时候用返回值也有点不太清楚，头脑中知识没梳理好，有点乱