2022-07-18 第二小组 张宁杰 Java面向对象

目录

1. 封装
2. 变量的类型
3. 成员方法
4. 访问权限修饰符
5. 面向对象和面向过程的区别
6. 面向对象3大特征
7. 8种基本数据类型
8. 栈和堆
9. 递归
10. 方法的重载
11. 不定长参数
12. 构造器

导图

知识点

知识点1

封装

要造车，必须有一个图纸，根据图纸，可以造一百台车。这个图纸就是在描述车的具体信息，对车的信息的封装。
员工工号，员工姓名，数组，两个数组。我们可能会需要几十个甚至上百个数组来维护一百辆车的信息，这是非常不合理的。

知识点2

变量的类型

分为成员变量（全局变量）和局部变量，声明在类里的变量就是成员变量（在类里也称作属性），声明在某个方法里的变量就是局部变量。

知识点3

成员方法

在声明方法时，括号里的参数，形式参数，形参，可以当做局部变量使用。在调用方法时，真正传入方法的参数，（实际参数，实参）

知识点4

访问权限修饰符

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

知识点5

面向对象和面向过程的区别

面向过程：面向过程就是分析出实现需求需要的步骤，通过一些方法一步一步实现。
面向对象（行为化）：把整个需求的按照特点、功能划分，将这些存在共性的部分封装成类（类实例化之后才是对象），让对象去解决问题。
面向对象更高级的抽象，是对现实世界的映射。

知识点6

面向对象的三大特征

1、封装
2、继承
3、多态
(4、抽象)

知识点7

8种基本数据类型

1、4种整数类型（byte、short、int、long）；
2、2种浮点类型（float、double）；
3、1种字符类型“char”；
4、1种布尔类型“boolean”。

知识点8

栈和堆

堆内存是是Java内存中的一种，它的作用是用于存储Java中的对象和数组，当我们new一个对象或者创建一个数组的时候，就会在堆内存中开辟一段空间给它，用于存放。
栈内存是Java的另一种内存，主要是用来执行程序用的，比如：基本类型的变量和对象的引用变量。
像car1,car2,car3....car100叫引用，它是指向内存中的一块区域。存放这些对象的空间，我们叫做堆。

知识点9

递归

递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。

package com.jsoft.afternoon;

/**
 * 成员方法
 * 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);
    }

    public void run(){
        run();
        System.out.println("汽车启动啦！");
    }

    // main方法 主方法
    /*
        如果一个方法有static
        要调用一个非static的方法
        就只能创建对象，使用对象.方法的形式调用
     */
    public static void main(String[] args) {
        Ch01 c = new Ch01();
//        c.run();
//        int i = c.fibonacci(3);
        int i = c.factorial(5);
        System.out.println(i);
    }

}

知识点10

方法重载

1.方法名相同
2.参数不同（参数的类型，参数的个数，参数的顺序）
3.发生在同一个类里
与返回值类型无关，与访问权限修饰符无，方法体无关
方法的重载的好处：
为了把功能相似相同的方法用同一个名字

public 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);
    }
}

知识点11

不定长参数

1.参数列表中，至多有一个不定长参数
2.不定长参数必须在最后位置
用这一个方法可以实现之前我们写过的方法重载的功能，这一个方法可以实现2个数，3个数，4个数，5个数.....数的相加，都是同一数据类型

public class Ch04 {
    public static void main(String[] args) {
        Ch04 c = new Ch04();
        System.out.println(c.a);
    }
    public void show(){
        System.out.println(a);
    }
    int a = 10;
     public int sum(String d,int ... arr){
        int result = 0;
        if(arr.length < 2){
            result = arr[0];
        }else {
            for (int i : arr) {
                result += i;
            }
        }
        return result;
    }
    public int sum(String d){

        return 0;
    }
}

知识点12

构造器

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

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);
    }
}
public class Ch06 {

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

    }
}

学习心得

感受

今天正式进入到了面向对象的学习中，我明显感受到了难度的提升，我们要具有抽象的思维，才能学好这部分的知识。

意见

建议