2022-07-18 第二组 曹雨 Java面向对象 类与方法

Java是一门面向对象的编程语言。在java中，万事万物皆对象

补充：在Linux中，万事万物皆文件

Java，面向对象三大特征：

1.封装 2. 继承 3.多态 4.抽象

面向过程和面向对象

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

面向对象：把整个需求按照特点、功能划分，将这些存在共性
的部分封装成类（类实例化之后才是对象），让对象去解决问题。

实际案例举例 汽车4s店

我们将汽车的多个属性进行打包，封装成类。在包下新建一个Car.java的类

public class Car {

// 车的品牌
// 只声明，不赋值。
String brand;
// 车的颜色
String color;
// 车的长度
long length;

将类打包后，你可以将类实体化，使其变为一个对象

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 + "米");

两块内存空间

1.栈2.堆

在图中，car1的位置在栈中，符合先进先出原则
而它的三个属性值，则存储在堆内存开辟的空间内
两者通过“=”连接进行赋值操作，car通过地址来寻找，使得栈中的元素能在堆内存中找到它对应的值。

引用数据类型

默认值为null
一旦有new，就不是null，而是地址

方法

• 定义一个成员方法
  跑的方法

  public：访问权限修饰符
  void：没有返回值
  run()：方法名，标识符
  {}：方法体。这个方法要干什么
  ()：传参数
  
  在声明方法时，括号里的参数，形式参数，形参，可以当做局部变量使用
  在调用方法时，真正传入方法的参数，实际参数，实参。
  
  参数可以有多个，中间用逗号隔开
  Java中的传参，需要明确数据类型
  
  标识符的命名规则：字母，数字，下划线，美元符号，数字不能开头
  1、类名：大驼峰
  2、属性名、方法名：小驼峰   
  
   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);
}

return关键字：

   1.return关键字终止方法继续执行。
   2.返回方法的返回值
   3.返回值用return xxx;类型要匹配
   4.在void方法中，也可以有返回值

访问修饰符

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

方法重载：

1.方法名相同
2.参数不同（类型，个数）
3.与返回值类型无关
4.发生在同一个类里

举例说明

public class Ch03 {

public int max(int num1,int num2) {

    return num1 > num2 ? num1:num2;
}

public int max(int num1,int num2,int num3){
    int a = (num1 > num2 ? num1 : num2);
    return a > num3 ? a : num3;
}

public static void main(String[] args) {
    Ch03 c = new Ch03();
    c.max(1,2,3);
}

好处：为了功能相同的方法，可以用同一个名字

方法的重写：
1.发生在不同的类里

不定长参数

递归

以编程的角度来看，递归指的是方法定义中调用方法本身的现象
把一个复杂的问题层层转化一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可以描述出解提过程需要的多次重复计算

注意事项

递归一定要有出口，否则内存溢出
递归虽然有出口，但是递归的次数也不宜过多，否则内存溢出

应用阶乘

pubilic static int jc(int n){
        if(n==1){ 
          return i
        } 
        else{
        return n=i*(n-1) }
        }

构造器

构造器（构造方法）
语法：
访问权限修饰符 类名(参数列表){

}
特点：
1.java在new对象的时候，先看对象所对应的类有没有构造器，有什么样的构造器。
如果没有构造器，则无法创建对象
2.每个类会有一个默认的无参的构造器
3.在对象被实例化时，调用了构造器
4.我们创建对象实际上是通过构造器创建的
5.如果一个类中显式的声明了一个构造器，原来默认自带的无参构造器就失效

总结

今天讲了，早上的知识感觉比较容易接受。但是到了下午，感觉方法的调用方式很杂，听到后面感觉整个人有些凌乱，后面的构造器听的也不是很清楚。课下自己再理解理解。