其他分享
首页 > 其他分享> > 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. 栈:变量,基本数据类型

引用数据类型的初始值为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