一、面向对象介绍

1. 面向对象介绍

① 面向：拿、找
② 对象：能干活的东西
③ 面向对象编程：拿东西过来做对应的事情

2. 面向对象重点学习什么

① 学习获取已有对象并使用
② 学习如何设计对象并使用

二、类和对象

1. 类和对象

① 类（设计图）：是对象共同特征的描述;
② 对象：是真实存在的具体东西
③ 在Java中，必须先设计类，才能获得对象

2. 如何定义类

① 格式

public class 类名{
    1.成员变量（代表属性，一般是名次）
    2.成员方法（代表行为，一般是动词）
    3.构造器（后面学习）
    4.代码块（后面学习）
    5.内部类（后面学习）
}

② 举例

public class Phone{
    // 属性（成员变量）
    String brand;
    double price;

    //行为（方法）
    public void call(){
    
    }
    public void playGame(){
    
    }
}

3. 如何得到类的对象

类名 对象名 = new 类名();
Phone p = new Phone();

4. 如何使用对象

① 访问属性：对象名.成员变量
② 访问行为：对象名.方法名()

5. 定义类的补充注意事项

① 用来描述一类事物的类，专业叫做：Javabean类。在Javabean类中，是不写main方法的。

② 在以前，编写main方法的类，叫做测试类。我们可以在测试类中创建javabean类的对象并进行赋值调用。

③ 类名首字母建议大写，需要见名知意，驼峰模式。

④ 一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个classs类。

⑤ 成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值;一般无需指定初始化值，存在默认值。

6. 练习

① Phone

package com.itheima.test;
public class Phone{
    //属性
    String brand;
    double price;
    
    //行为
    public void call(){
        System.out.println("手机在打电话");
    }
    public void playGame(){
        System.out.println("手机在玩游戏");
    }    
}

package com.itheima.test;
public class PhoneTest{
    public static void main(String[] args){
    
        //创建手机的对象
        Phone p = new Phone();
        //叫做给手机赋值
        p.brand = "小米";
        p.price = 1999.98;
        
        //获取手机对象中的值
        System.out.println(p.brand);
        System.out.println(p.price);
        
        //调用手机中的方法即可
        p.call();
        p.playGame();

        Phone p2 = new Phone();
        p2.brand = "苹果";
        p2.price = 8999;
        
        p2.call();
        p2.playGame();
    }
}

② GirlFriend

package com.itheima.test2;
public class GirlFriend{
    //属性
    String name;
    int age;
    String gender;

    //行为
    public void sleep(){
        System.out.println("女朋友在睡觉");
    }
    
    public void eat(){
        System.out.println("女朋友在吃饭");
    }    
}

package com.itheima.test2;
public class GirlFriendTest{
    public static void main(String[] args){
        //创建女朋友的对象
        GirlFriend gf1 = new GirlFriend();
        gf1.name = "小诗诗";
        gf1.age = 18;
        gf1.gender = "萌妹子";
        
        System.out.println(gf1.name);
        System.out.println(gf1.age);
        System.out.println(gf1.gender);
        
        gf1.eat();
        gf1.sleep();
        
        GirlFriend gf2 = new GirlFriend();
        gf2.name = "小丹丹";
        gf2.age = 19;
        gf2.gender = "萌妹子";
        
        System.out.println(gf2.name);
        System.out.println(gf2.age);
        System.out.println(gf2.gender);
        
        gf2.eat();
        gf2.sleep();        
    }
}

三、封装

1. 封装

① 定义：告诉我们，如何正确设计对象的属性和方法
② 原则：对象代表什么，就得封装对应的数据，并提供对应的行为

2. 好处

① 让编程变得简单，有什么事，找对象，调方法就行
② 降低我们的学习成本，可以少学，少记，或者说压根不用学，不用记对象有哪些方法，有需要时去找就行

3. private关键字

① 是一个权限修饰符
② 可以修饰成员（成员变量和成员方法）
③ 被private修饰的成员只能在本类中才能访问
④ 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
⑤ 提供set(参数)方法，用于给成员变量赋值，方法用public修饰
⑥ 提供get()方法，用于获取成员变量的值，方法用public修饰

4. 练习

① GirlFriend

package com.itheima.test3;
public class GirlFriend{
    //属性
    private String name;
    private int age;
    private String gender;


    //针对每一个私有化的成员变量，都要提供get和set方法
    //set方法：给成员变量赋值
    //get方法：对外提供成员变量的值

    //作用：给成员变量name进行赋值的
    public void setName(String n){
        name = n;
    }

    //作用：对外提供name属性的
    public String getName(){
        return name;
    }

    //age
    //setAge：给成员变量age进行赋值
    //getAge：对外提供成员变量age的值

    public void setAge(int a){
        if(a >= 18 && a <= 50){
            age = a;
        }else{
            System.out.println("非法参数");
        }
    }
    
    public int getAge(){
        return age;
    }

    //gender
    public void setGender(String g){
        gender = g;
    }

    public String getGender(){
        return gender;
    }
    
    //行为
    public void sleep(){
        System.out.println("女朋友在睡觉");
    }
    
    public void eat(){
        System.out.println("女朋友在吃饭");
    }    
}

package com.itheima.test2;
public class GirlFriendTest{
    public static void main(String[] args){
        //创建女朋友的对象
        GirlFriend gf1 = new GirlFriend();
        gf1.setName("小诗诗");
        gf1.setAge(18);
        gf1.setGender("女");

        System.out.println(gf1.getName());
        System.out.println(gf1.getAge());
        System.out.println(gf1.getGender());
        
        gf1.eat();
        gf1.sleep();
        
    }
}

四、就近原则和this关键字

1. 成员变量和局部变量

public class GirlFriend{
    private int age;  //成员变量
    public void method(){
        int age = 10;  //局部变量
        System.out.println(age);
    }
}

2. this的作用

可以区别成员变量和局部变量

3. 练习

① GirlFriend

package com.itheima.test4;
public class GirlFriend{
    //属性
    private int age;//0
    
    public void method(){
        int age = 10;
        System.out.println(age);//谁离我近，就是谁
        System.out.println(this.age);
    }
}

package com.itheima.test4;
public class GirlFriendTest{
    public static void main(String[] args){
        GirlFriend gf1 = new GirlFriend();
        
        gf1.method();
    }
}

五、构造方法

1. 构造方法概述

① 构造方法也叫作构造器、构造函数
② 作用：在创建对象的时候给成员变量进行赋值

2. 构造方法的格式

格式

public class Student{
    修饰符 类名(参数){
        方法体;
    }
}

特点

① 方法名与类名相同，大小写也要一致
② 没有返回值类型，连void都没有
③ 没有具体的返回值（不能由return带回结果数据）

执行时机
① 创建对象的时候由虚拟机调用，不能手动调用构造方法
② 每创建一次对象，就会调用一次构造方法

3. 构造方法注意事项

① 构造方法的定义

如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

② 构造方法的重载

带参构造方法，和无参构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载

③ 推荐的使用方式

无论是否使用，都手动书写无参构造方法，和全部参数的构造方法

4. 练习

① Student

package com.itheima.test5;
public class Student{
    private String name;
    private int age;
    
    //如果我们自己没有写任何的构造方法
    //那么虚拟机给我们加一个空参构造方法
    public Student(){
        System.out.println("看看我执行了吗？");
    }
    
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return name;
    }
    public void setName(){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(){
        this.age = age;
    }
}

package com.itheima.test5;
public class StudentTest{
    public static void main(String[] args){
        //创建对象
        //调用的空参构造
        //Student s = new Student();

        Student s = new Student("zhangsan",23);        
        System.out.println(s.getName());
        System.out.println(s.getAge());
    }
}

5. 总结

① 构造方法的作用：创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的

② 构造方法有几种，各自的作用是什么

无参构造方法：初始化对象时，成员变量的数据均采用默认值
有参构造方法：在初始化对象的时候，同时可以为对象进行赋值

③ 构造方法有哪些注意事项

任何类定义出来，默认就自带了无参构造器，写不写都有
一旦定义了有参构造器，无参数构造器就没有了，此时就需要自己写无参构造器了
建议在任何时候都手动写上空参和带全部参数的构造方法

六、标准的javabean类

1. 标准的JavaBean类

① 类名要见名知意
② 成员变量使用private修饰
③ 提供至少两个构造方法
无参构造方法
带全部参数的构造方法
④ 成员方法
提供每一个成员变量对应的set()和get()
如果还有其他行为，也需要写上

2. 练习

① User

package com.itheima.test6;
public class User{
    //属性
    private String username;
    private String password;
    private String email;
    private String gender;
    private int age;

    //空参
    public User(){}
    //带全部参数的构造

    //快捷键
    //alt + insert
    //alt + Fn + insert
    public User(String username,String password,String email,String gender,int age){
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }


    //插件PTG
    /**
     * 获取
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     * @return email
     */
    public String getEmail() {
        return email;
    }

    /**
     * 设置
     * @param email
     */
    public void setEmail(String email) {
        this.email = email;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }
       
}

七、对象的内存图

1. 一个对象的内存图

① 加载class文件
② 声明局部变量
③ 在堆内存中开辟一个空间
④ 默认初始化
⑤ 显示初始化
⑥ 构造方法初始化
⑦ 将堆内存中的地址值赋值给左边的局部变量

2. 两个对象的内存图

3. 两个引用指向同一个对象

八、基本数据类型和引用数据类型

1. 从内存的角度去解释

① 基本数据类型：数据值是存储在自己的空间中
特点：赋值给其他变量，也是赋的真实的值

② 引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值
特点：赋值给其他变量，赋的地址值

九、this的内存原理

1. this的作用

区分局部变量和成员变量

2. this的本质

所在方法调用者的地址值

十、成员和局部

1. 成员变量和局部变量的区别