2022-07-18 闫馨月第七小组学习笔记

我不是你你不是我

已于 2022-07-19 14:55:15 修改

阅读量120

点赞数

分类专栏： JAVA 文章标签： java 开发语言学习

于 2022-07-19 14:54:34 首次发布

本文链接：https://blog.csdn.net/qq_53558022/article/details/125857119

版权

JAVA 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

面向对象

特征：封装（最重要！！）、多态、继承、抽象。

java是面向对象的编程语言，在java中，万事万物皆为对象（在LINUX中，万事万物皆为文件）。

好处：将复杂的事情简单化、面向对象将以前的过程中的执行者，变成了指挥者、面向对象这种思想是符合现在人们思考习惯的一种思想。

面向过程和面向对象

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

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

高级的编程语言会向着人的思考靠近面向对象更高级的抽象，是对现实世界的映射，成员变量就是属性，在整个类里都能用。

封装

好处：安全、隔离变化、操作简单、可重复使用。

修饰限定符：

访问权限（4个都可以修饰构造器）

public：一个工程下任意位置都可以访问，可以修饰类、方法、属性、构造方法上

默认的：只有当前包下可以访问，把包导进来也不行能放在类、属性、方法

protected：可以跨包，如果跨包，必须是它的子类只能放在属性和方法上

private：私有的最小只有当前类可以访问

创建一个学生类：

class Student {
    public String name;//学生姓名
    public int age;//学生年龄
    public String sex;//学生性别
    public double score;//学生分数
    public void sleep() {
        System.out.println("我要睡觉了！！！");
    }
    public void eat() {
        System.out.println("我要干饭了！！！");
    }
    public void exam() {
        System.out.println("我要考试了！！！");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student = new Student();//利用new关键字实例化一个对象
        student.age = 19;
        student.name = "西门";
        student.score = 99.9;
        student.sex = "男";
    }
}

思考：如果我们每次要定义一个学生对象，每次都要这样赋值会不会有点太麻烦？因此用到封装就会让它更简单一些。

代码：

class Student {
    private String name;//学生姓名
    private int age;//学生年龄
    private String sex;//学生性别
    private double score;//学生分数
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("西门");
        System.out.println(student.getName());
    }
}

加了private访问修饰限定符，使得成员变量和方法只能在本类的里面进行访问。加了private，name就不能在类的外部访问。

class Student {
    private String name;//学生姓名
    private int age;//学生年龄
    private String sex;//学生性别
    private double score;//学生分数

构造器（构造方法）

语法：访问权限修饰符类名(参数列表){ ....}

特点：

1.java在new对象的时候，先看对象所对应的类有没有构造器，有什么样的构造器。如果没有构造器，则无法创建对象

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

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

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

5.如果一个类中显式的声明了一个构造器，原来默认自带的无参构造器就失效

public class Ch06 {
    public static void main(String[] args) {
        // 创建对象的过程，实例化的过程，创建一个Dog类的实例
        // 类名 对象名 = new 构造器;
        Dog dog = new Dog("");

    }
}

Dog：

package com.jsoft.afternoon;

public class Dog {

    String name;
    String color;
    int age;

    public Dog(String str){
        System.out.println(str);
    }
    Dog(){

    }

    public Dog(int a,int ... arr){

    }

    public void show(){
        System.out.println("名字：" + name + "，颜色：" + color + "，年龄：" + age);
    }
}

斐波那契数列

什么事斐波那契数列？

借用一下度娘的一段话：斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……其规律很明显，从第3个数开始，每个数都等于它前两个数的和。

我们知道除了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)

通过java可以实现斐波那契数列。

1.通过递归实现

 public int fibonacci(int number){
        if(number == 0 || number == 1){
            return number;
        }else {
            return fibonacci(number - 1) + fibonacci(number - 2);
        }
    }

2.通过for循环实现

public static long fibonacci2(int n) {
        if (n < 1) {
            return -1;
        }
        if (n ==1 || n == 2) {
            return 1;
        }

        long a =1L, b= 1L, c =0L;		//定义三个long类型整数
        for (int i = 0; i < n - 2; i++) {
            c = a + b;			//第3个数的值等于前两个数的和
            a = b;			//第2个数的值赋值给第1个数
            b = c;			//第3个数的值赋值给第2个数
        }
        return c;
    }

重载

java允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）。

JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。

public void println(int i){…}
public void println(double d){…}
public void println(String s){…}

这些方法完成的功能类似，都是格式化输出。根据参数的不同来区分它们，以进行不同的格式化处理和输出。它们之间就构成了方法的重载。实际调用时，根据实参的类型来决定调用哪一个方法。

System.out.println(102);    // 调用println(int i)方法
System.out.println(102.25);    // 调用println(double d)方法
System.out.println("价格为 102.25");    // 调用println(String s)方法

方法重载的要求是两同一不同：同一个类中方法名相同，参数列表不同（参数的类型，参数的个数，参数的顺序）方法返回值类型、修饰符等，与方法重载没有任何关系。

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

方法的重载的好处：为了把功能相似相同的方法用同一个名字。

public class OverLoading {
    public void max(int a, int b) {
        // 含有两个int类型参数的方法
        System.out.println(a > b ? a : b);
    }

    public void max(double a, double b) {
        // 含有两个double类型参数的方法
        System.out.println(a > b ? a : b);
    }

    public void max(double a, double b, int c) {
        // 含有两个double类型参数和一个int类型参数的方法
        double max = (double) (a > b ? a : b);
        System.out.println(c > max ? c : max);
    }

    public static void main(String[] args) {
        OverLoading ol = new OverLoading();
        System.out.println("1 与 5 比较，较大的是：");
        ol.max(1, 5);
        System.out.println("5.205 与 5.8 比较，较大的是：");
        ol.max(5.205, 5.8);
        System.out.println("2.15、0.05、58 中，较大的是：");
        ol.max(2.15, 0.05, 58);
    }
}

为什么方法重载不能用方法的返回值类型区分呢？

对于int(){}和void(){}两个方法，如果这样调用int result=a();系统可以识别是调用返回值类型为 int 的方法，但 Java 调用方法时可以忽略方法返回值，如果采用如下方法来调用a();