其他分享
首页 > 其他分享> > 2022-07-18 第二组 卢睿 学习心得

2022-07-18 第二组 卢睿 学习心得

作者：互联网

Java面向对象

今日重点

面向过程与面向对象
面向对象三大特征：继承，封装，多态
成员变量，局部变量
类，对象，实例化
引用数据类型
访问权限修饰符
递归
重载
构造器

思维导图

image

学习感想

今天学的java面向对象，感觉这个知识点有点抽象，有点难理解，封装可以想象成函数，就会很好的理解了，主要是写方法，然后调用方法，感觉还好，多理解，多练练就会了。

前言

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

面向过程和面向对象

面向过程：面向过程就是分析出实现需求的步骤，通过一些方法一步一步实现。
面向对象（行为化），把整个需求的按照特点，功能划分，将这些存在共性的部分封装成类（类实例化之后才是对象），让对象去解决问题。
举一个例子：
要送一个包
面向对象：找个店，买个包，不管是商家，还是包邮都是现实中真实存在的事物，这个商店或者包，我们就可以称之为对象，在整个的你去买包，或商家卖包的，就是面向对象
面向过程：找到原材料，自己切割，自己缝制，每一个工序都自己做，这就是面向过程

其实，高级的编程语言，会向着人的思考靠近，对现实世界的映射
String,Scanner 我们在使用Scanner的时候，从来没有考虑过Scanner为什么可以键盘输入
这是别人给我们创建的对象，事实上我们也能自己创建对象，在开发中，基本上我们会大量的自己创建自己的对象

我们准备开一个4s店，我需要有车，需要有门店，
先说说我们怎么去用代码描述一辆车
车：描述信息，描述信息叫做属性，属性实际上从代码的角度来说就是变量。
定义好多的变量：1、brand 2、color 3、length
问题又来了，怎么才能描述好几个车？

员工工号，员工姓名。数组，两个数组
我们可能会需要几十个甚至上百个数组来维护一百辆车的信息

在java中，面向对象有三大特征

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

成员变量

把变量直接声明在类里
也可以叫做属性

局部变量

把变量声明咋某个方法里

封装

  1. 代码层面
  2. 思想层面

类，对象，实例化

把描述和实操尽量分离开
eg：
类

package com.morning;

public class Car {

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

}

对象

package com.morning;

public class Ch01 {
    public static void main(String[] args) {
        //根据图纸去造车
        //创建对象的过程，类的实例化的过程，对象有叫做累的一个实例
        //创建一个Car类的对象car1
        //这个car1就是对象的名
        //其实这个car1就是个标识符
        //对象名的命名规则：小驼峰
        //创建对象的语法：类名 对象名 = new 类名（）
        Car car1 = new Car();
        //给车的属性赋值
        car1.brand = "奥迪";
        car1.color = "白色";
        car1.length = 5L;

        //取出属性的值
        System.out.println("生产了第一台车，它的属性是：" + car1.length + "." + car1.color + "," + car1.length);

        Car car2 = new Car();
        car2.brand = "保时捷";
        car2.color = "黑色";
        car2.length = 6L;
        System.out.println("生产了第二台车，它的属性是：" + car2.length + "." + car2.color + "," + car2.length);
        /*
            car1和car2都是Car类的一个实例（对象）
            但是他们之间是相互隔离的

            Car是类，只有一份
            car1 car2...car100是根据类构建出来的
         */
    }
}

重点

  1. 之前我们学习过8种基本数据类型
  2. 从今天开始，我们的数据类型就更多了，我们能够遇见的所有的类，包括我们刚刚创建的Car是一种数据类型，所有的类都是数据类型，它们都是引用数据类型，此刻起，我们才真正了解了class这个关键字，创建一个类，用来创建一个数据类型
    像car1、car2、。。。。car100叫引用，它是指向内存中的一块区域，有地址
    我们需要了解两块内存：
  3. 栈：变量，基本数据类型
  4. 堆

引用数据类型的初始值为null，只要看见了new，就不是null，它就有地址
Car car；声明了一个Car类型的属性car
赋值时，除了String外，其余的引用数据类型都要new

方法

成员方法（Js里的函数）
一个汽车只有颜色，品牌这些属性，它就是一块废铁

 * 定义一个成员方法
 * public：；访问权限修饰符
 * void：没有返回值
 * run(): 方法名，标识符
 * {}：方法体。这个方法要干什么
 * （）：传参数
 *
 * 形参，局部变量
 * 实参，真正具体的值
 *
 *参数可以有多个，中间有逗号隔开
 * Java中的传参，需要明确数据类型
 * 可以自动类型转换
 *
 * 标识符的命名规则
 * 1.类名，大驼峰
 * 2.属性名，方法名 ：大驼峰
 *
     //有返回值的方法

//        public：
//        boolean,返回值类型，运行后，得到一个具体的值，返回值类型是boolean
//        返回值用return xxx，类型要匹配
//
//
//        开发中，大部分的方法有返回值
//        return关键字
//            1.return关键字终止方法继续执行
//

访问权限修饰符

public 公有的，公共的，最大，只要是public声明的方法，只要在同一个工程中都能访问（可以放在属性，类，方法上，构造器）
protected 受保护的，可以跨包，如果跨包，必须是它的子类（属性，方法，构造器）
默认的，友好的：当前包下可以访问（类，属性，方法构造器）
private：私有的，最小，只有在当前类可用（属性，方法）
java.long包下的所有的类不需要显示的导入

        //创建对象的过程，类的实例化的过程，对象有叫做累的一个实例
        //创建一个Car类的对象car1
        //这个car1就是对象的名
        //其实这个car1就是个标识符
        //对象名的命名规则：小驼峰
        //创建对象的语法：类名 对象名 = new 类名（）

成员变量

  1. 方法名不能重复

自己调自己，递归
递归的问题：Stack OverflowError 栈溢出 内存溢出
开发中要不要用递归，如果用的话，要注意什么？

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

菲波那切数列（递归）

package com.afternoon;

public class Ch01 {
    //斐波那契额数列
    //除了0和1，第number个数字
    //等于第number-1个数和第number-2个数的和
    public int fibonacci(int number) {
        if (number == 0 || number == 1){
            return number;
        }else{
            return fibonacci(number-1) + fibonacci(number-2);
        }
    }

    public static void main(String[] args) {
        Ch01 c = new Ch01();
        System.out.println(c.fibonacci(6));
    }
}

方法的重载

  1. 方法名相同
  2. 参数不同(参数的类型，参数的个数，参数的顺序)
  3. 发生在同一个类里

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

用一个方法实现多个数的相加

package com.afternoon;

public class Ch04 {
    ///用一个方法实现多个数的相加
    public int sum (int []arr){
        int result = 0;
        if (arr.length<2){
            result =  arr[0];
        }else{
            for (int i:arr
                 ) {
                result += i;
            }
        }
        return result;
    }
    public static void main(String[] args) {
        Ch04 c = new Ch04();
        int []arr = new int[]{1,2,3,4};
        System.out.println(c.sum(arr));
    }
}

不定长参数

  1. 参数列表中，至多有一个不定长参数
  2. 不定长参数必须在最后位置
package com.afternoon;

public class Ch04 {
    ///用一个方法实现多个数的相加
    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 static void main(String[] args) {
        Ch04 c = new Ch04();
//        int []arr = new int[]{1,2,3,4};
//        System.out.println(c.sum(arr));
        c.sum("1",1,2,3,4);
    }
}

构造器（构造方法）

语法

访问权限修饰符 类名（）{

}

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

类名 对象名 = new 构造器；

类与类的关系

has a

标签：07,对象,18,car1,数据类型,2022,Car,方法,public
来源： https://www.cnblogs.com/lurui711/p/16491644.html