关于java:JavaSE学习笔记Day07

面向对象是一种编程思维
- 领导以什么模式组织代码
- 领导以什么思路解决问题
问题 : 为什么要学这种思维呢 ?

因为这套思维来源于生存, 生存中解决问题时, 就是一个个的对象在一起打交道从而将问题解决
所以心愿本人写代码的时候, 也能应用这套思维, 代码的编写就会更加简略.

- 举例:
        1. 解决产生随机数的问题 ---> Random 对象
        2. 解决键盘录入的问题  ---> Scanner 对象
        3. 封装学生的信息 ---> Student 对象
        ...
            
- Java 考究万物皆对象

面向对象学什么 ?
- 学习本人如何设计对象
- 学习已有的对象如何应用 (API 阶段)

前提 : Java 中想要创建对象, 必须要先有类的存在
类 : 是一组相干属性和行为的汇合, 将其看做为是对象的设计图
对象 : 依据类 (设计图) 创立进去的实体.
关系 :
- 依赖关系 : 须要依据类创建对象
- 数量关系 : 一对多的关系, 依据一个类创立出多个对象
类的组成 :

类是设计图, 设计图的实质是对事物进行形容

属性(名词) :

    成员变量: 跟之前定义变量的格局一样, 只不过地位产生了扭转, 类中办法外.

行为(动词) : 

    成员办法: 跟之前定义方法的格局一样, 只不过去掉了 static 关键字.

class Student {
    
    String name;
    int age;
    
    public void eat(){...}

}

留神 : 当类写好了之后, 须要在测试类中创建对象再应用

class Test {public static void main(String[] args){// 创建对象格局: 类名 对象名 = new 类名();
        Student stu = new Student();
        
        System.out.println(stu);        // 地址值 :  com.itheima.oop.Student@233ac4a
        
        // 成员变量没有赋值, 间接应用
        // 应用成员变量格局: 对象名. 变量名;
        System.out.println(stu.name);   // null
        System.out.println(stu.age);    // 0
        
        stu.name = "张三";
        stu.age = 23;
        
        System.out.println(stu.name);   // 张三
        System.out.println(stu.age);    // 23
        
        // 应用成员办法格局: 对象名. 办法名(理论参数);
        stu.eat();}
}

单个对象内存图
两个对象内存图

1. 类中编写地位不同

        成员变量: 办法外
        局部变量: 办法中

2. 初始化值不同

        成员变量: 有默认初始化值
        局部变量: 没有默认初始化值, 应用之前必须赋值能力应用

3. 内存地位不同
        
        成员变量: 堆内存
        局部变量: 栈内存

4. 生命周期不同

        成员变量: 随着对象的创立而存在, 随着对象的隐没而隐没
        局部变量: 随着办法的调用而存在, 随着办法的弹栈而隐没

5. 作用域
        都在本人所属的大括中无效

景象 : 当成员变量和局部变量重名了, 在没有任何标识的状况下, Java 会依据就近准则, 优先应用局部变量

class Student {
    int num = 10;
    
    public void show(){
        int num = 20;
        System.out.pritnln(num);
    }
}


Student stu = new Student();
stu.show();        // 20   Java 会依据就近准则, 优先应用局部变量

问题 : 非要应用成员变量, 怎么辨别 ?
答复 : 应用 this 关键字

class Student {
    int num = 10;
    
    public void show(){
        int num = 20;
        System.out.pritnln(this.num);
    }
}


Student stu = new Student();
stu.show();        // 10

论断 : this 调用本类成员 (变量, 办法)

this. 本类成员变量
this. 本类成员办法();

-----------------------------

省略 this 的规定: 
        1. 调用成员办法, 没有前提条件, this. 能够间接省略
        2. 调用成员变量, 须要保障没有重名, this. 才能够省略

this 介绍 : 代表以后类对象的援用 (地址) 谁来调用我, 我就代表谁

p1.show(); ----> this ---> p1 的地址
p2.show(); ----> this ---> p2 的地址

构造方法 | 结构器 : 创建对象的时候, 要执行的办法
格局 :

1. 办法名与类名雷同, 大小写也须要统一
2. 没有返回值类型, 连 void 都没有
3. 没有具体的返回值 (不能通过 retrun 带回后果数据)
        - 细节: 能够 return;

构造方法的执行机会 :

1. 创建对象的时候, 被零碎调用执行
2. 每创立一次对象, 就会执行一次构造方法.

构造方法的作用 :

实质作用: 创建对象
联合执行机会: 在创建对象的时候, 给成员变量赋值

            Student stu = new Student("张三", 23);

            思考过程: 构造方法在创建对象的时候, 肯定会执行, 你就别闲着了, 帮我干点活
                        - 给成员变量初始化

注意事项 :

1. 如果一个类, 没写构造方法, 零碎会提供一个 [默认的] [无参数的] 构造方法
2. 如果手动编写过构造方法, 零碎将不会再提供那个默认的无参结构了
        
        倡议: 无参, 带参构造方法, 都手动给出.
        
3. 构造方法不容许对象名. 的模式调用

介绍 : 暗藏实现细节, 仅对外裸露公共的拜访形式
封装在代码中常见的体现 :

应用封装前:

        String id = "001";
        String name = "张三";
        int age = 23;
        String tel = "156xxxxxxxx";
        String address = "北京";
        
        操作的, 是 5 个零散的数据.
        
-------------------------------------------------

应用封装后:

        class User {
            private String id;
            private String name;
            private int age;
            private String tel;
            private String address;
            
            // 生成空参带参结构, setXxx 和 getXxx
        }
        
        User u1 = new User("001","张三",23,"156xxxxxxxx","北京");

        操作的, 是一个整体的对象
            
感触: 本来是零散的数据, 当初被封装成一个整体了.
    
论断: 将属性抽取到类中, 是对数据进行的封装.

程序员 A :

        public void pirntArray(int[] arr){... 遍历打印数组的代码 ...}
        
程序员 B :
        
        只须要关怀办法能干什么, 以及办法怎么用即可, 至于外部的逻辑实现, 无需关注
        
        程序员 A, 将遍历打印数组的代码逻辑, 封装到了办法中.
        
论断: 将代码抽取到办法中, 是对代码性能进行的封装.

private : 同一个类中
(default) : 同一个类中, 同一个包中
protected : 在一个我的项目中，不能够有雷同的两个包名，也就是说，包名不能和我的项目中其余的包名反复，这里岂但包含自定义包名也包含我的项目所援用的类库的包名
public : 任意地位拜访

成员变量 private 私有化
提供空参, 带参构造方法
针对于公有的成员变量, 提供对应的 setXxx 和 getXxx 办法.

package com.itheima.test;

/*
    1. 公有成员变量 private
    2. 提供空参, 带参构造方法
    3. 针对公有的成员变量, 提供 setXxx 和 getXxx 办法
 */
public class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}
}

package com.itheima.test;

public class StudentTest {public static void main(String[] args) {
        // 1. 空参结构创建对象, setXxx 赋值
        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(23);
        System.out.println(stu1.getName() + "---" + stu1.getAge());

        // 2. 带参结构创建对象, 在创建对象的时候, 间接赋值
        Student stu2 = new Student("李四",24);
        System.out.println(stu2.getName() + "---" + stu2.getAge());

        // 倡议: 一般来说, 带参结构创立做初始化, 前期如果波及到批改, 应用 setXxx

        // 留神: getXxx 办法, 是获取到实在的数据.
        for(int i = 1; i <= stu2.getAge(); i++){System.out.println(stu2.getName() + "生日快乐");
        }
    }
}

关于java:JavaSE学习笔记Day07

JavaSEDay07 总结笔记

01- 面向对象介绍

02- 类和对象

03- 对象内存图

04- 成员变量和局部变量的区别

05-this 关键字

06- 构造方法

07- 封装 (重点)

08- 权限修饰符

09- 规范 JavaBean (必把握)