java basic 07

day08 总结笔记 第七天没有笔记

01-面向对象介绍

• 介绍 : 面向对象是一种编程的指导思想
• 问题 : 为什么要学习面向对象这种思想 ?

这套思想来源于生活, 生活中解决问题的时候, 就是一个个的对象在一起打交道, 从而将问题解决
我们希望写代码的时候, 也能使用这套思想, 编程就会更加贴切于生活.

- 解决随机数的问题 --> 找来了Random对象
- 解决键盘录入的问题 --> 找到了Scanner对象
- 解决封装学生信息的问题 --> 找到了Student对象

• 面向对象重点学什么 ?

1. 学习自己如何设计对象
2. 学习已有的对象如何使用  --- API章节

02-类和对象

• 前提需知 : Java 中想要创建对象, 必须要先有类的存在

• 类的介绍 : 一组相关属性和行为的集合, 将其看做为是对象的设计图

  • 类 : 设计图
  • 对象 : 根据设计图创建出来的实体

• 类和对象 :

  • 依赖关系 : 需要根据类, 创建对象
  • 数量关系 : 一对多的关系

• 类的组成 :

  • 属性(名词描述) :

  属性在代码中, 使用成员变量表示, 成员变量跟之前定义变量的格式一样, 只不过位置发生了改变, 放在了类中, 方法外.
  

  • 行为(动词描述) :

  行为在代码中, 使用成员方法表示, 成员方法跟之前定义方法的格式一样, 只不过去掉了static关键字
  

  public class Student {
  	// 属性: 姓名, 年龄
  	String name;
  	int age;
  	
  	// 行为: 学习, 吃饭
  	public void study(){
  		System.out.println("学习");
  	}
  	
  	public void eat(){
  		System.out.println("吃饭");
  	}
  }
  

03-对象的创建和使用

• 使用一个类 , 需要定义一个带有main方法的测试类
• 创建类的对象, 调用内部的成员变量, 成员方法

public class StudentTest {
	public static void main(String[] args){
		
	}
}

• 创建对象的格式 :

  • 类名 对象名 = new 类名();

  Student stu = new Student();
  System.out.println(stu);		// 打印对象名, 看到对象在内存中的地址值
  

• 使用成员变量的格式 :

  • 对象名.变量名;

  // 如果成员变量没有赋值, 直接打印,
  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.study();
  stu.eat();
  

04-对象内存图

• 务必打开ppt, 将内部的流程梳理清楚

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

1. 类中位置不同 :

	成员变量: 方法外
	局部变量: 方法中
	
2. 初始化值不同 :
	
	成员变量: 有默认初始化值
	局部变量: 没有默认初始化值, 使用之前必须完成赋值
	
3. 内存位置不同 :

	成员变量: 堆内存
	局部变量: 栈内存
	
4. 生命周期不同 :

	成员变量: 随着对象的创建而存在, 随着对象的消失而消失
	局部变量: 随着方法的调用而存在, 随着方法的运行结束而消失
	
5. 作用域 :

	都在自己所属的大括号中有效

06-this关键字

• 情况 : 成员变量和局部变量重名了, 在使用的时候, 会根据就近原则, 优先使用局部变量

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

public class Test {
    public static void main(String[] args){
        Student stu = new Student();
        stu.show();
    }
}

• 区分局部变量和成员变量的重名

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

public class Test {
    public static void main(String[] args){
        Student stu = new Student();
        stu.show();
    }
}

• this 的作用 :
  • this可以使用点儿的形式调用本类的成员
  • this.本类成员变量
  • this.本类成员方法

省略规则: 

	1. this.本类成员方法 : 没有任何前提条件, this.可以直接省略掉
	2. this.本类成员变量 : 需要保证变量名不重复(前提条件) this.才可以省略

• this 的介绍 :
  • 代表当前类对象的地址, 哪一个对象调用的方法, 方法中的this, 代表的就是哪一个对象

stu1.show();  ---> this ----> stu1的地址
stu2.show();  ---> this ----> stu2的地址

07-构造方法

• 介绍 :
  • 构造方法 | 构造器
  • 创建对象的时候, 要执行的方法
• 格式 :
  • 方法名与类名相同, 大小写也必须一致
  • 没有返回值类型, 连void都没有
  • 没有具体的返回值 (方法中, 不能通过return语句带回结果)

public class Student {

	public Student(){
		System.out.println("Student类的空参数构造方法...");
	}
	
}

• 构造方法的执行时机 :

  • 创建对象的时候被调用执行

  Student stu = new Student();
  
  Student(); ---> 单独看这句代码, 就是在调用构造方法
  

  • 每创建一次对象, 就会执行一次构造方法

• 构造方法的作用 :

  • 本质作用 : 用于创建对象
  • 结合执行时机 : 可以在创建对象的时候, 给成员变量赋值
    • 你不是在创建对象的时候, 一定会执行吗, 那你执行的时候, 别闲着了, 帮我干点活, 给成员变量赋值

public class Student {

	String name;
	int age;

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


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

• 构造方法的注意事项 :

  • 如果一个类中, 没写任何构造方法, 系统将会提供一个 [默认的] [无参数的] 构造方法, 保证可以正常创建对象

  public Student(){
  
  }
  
  因为默认提供的构造方法, 里面没有代码执行, 所以我们之前感受不到, 构造方法在执行
  

  • 如果一个类中, 手动编写过构造方法, 系统就不会再提供那个默认的无参构造了
    • 建议 : 无参构造方法, 带参构造方法, 全部手动给出
  • 构造方法, 不允许使用对象名.的形式调用

08-封装

• 面向对象三大特征

  • 封装
  • 继承
  • 多态

• 封装思想 :

  • 隐藏实现细节, 仅对外暴露公共的访问方式

• 封装在代码中常见的体现 :

  • 将属性抽取到类中, 是对零散的数据, 进行了封装

  用户信息:
  
  001
  张三
  23
  15611111111
  北京
  
  ---------------------------------
  
  使用封装前:
  
  String id = "001";
  String name = "张三";
  int age = 23;
  String tel = "15611111111";
  String address = "北京";
  
  使用的数据, 是零散的5个变量.
  
  ---------------------------------
  
  使用封装后:
  
  class User {
  	String id;
  	String name;
  	int age;
  	String tel;
  	String address;
  	
  	// 假设编写了构造方法
  }
  
  User u = new User("001","张三",23,"15611111111","北京");
  
  使用的数据, 不再是零散的变量了, 而是存到了一个整体的对象中
  

• 将代码逻辑, 抽取到方法中, 是对代码进行的一种封装

  程序员A : 编写了一个方法, printArray() 一个遍历打印数组的方法
  
  程序员B : 只需要关心方法怎么调用即可, 不需要关系内部的逻辑
  
  			这就是程序员A, 对遍历打印数组的代码逻辑, 进行了封装.
  

09-权限修饰符

• private : 同一个类中
• (default) : 同一个类中, 同一个包中
• protected : 就业班学
• public : 可以在任意位置访问

10-标准JavaBean类

• 成员变量全部 private
• 提供空参, 带参构造方法
• 针对于私有的成员变量, 编写对应的 setXxx 和 getXxx 方法

package com.itheima.test;

/*
    标准的JavaBean :

        1. 成员变量全部私有

        2. 提供空参, 带参构造方法

        3. 针对于私有的成员变量, 编写对应的 setXxx 和 getXxx 方法

        ptg插件
 */
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 {
    /*
        一般通过带参构造方法, 对数据做初始化 (第一次赋值)
            后期如果需要修改, 调用setXxx即可
     */
    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);
        stu2.setName("赵四");
        System.out.println(stu2.getName() + "---" + stu2.getAge());

        // 注意: getXxx方法, 是能够让你拿到真实的数据
        for(int i = 1; i <= stu2.getAge(); i++){
            System.out.println("祝:" + stu2.getName() + "生日快乐!");
        }
    }
}