Day8-面向对象

1、设计对象并使用

（1）、类和对象。（在Java中，必须先设计类，才能获得对象。使用对象必须依赖于类，没有类就没有对象）

类：共同特征的描述。对于一类具有相同属性和行为的抽象，是一个抽象的概念看不见摸不着。

对象：是真实存在的具体案例。对象是类的一个具体呈现，是一个实实在在存在的事务。

（2）、如何定义类。

public calss 类名 {
    1、成员变量(代表属性，一般是名词)
    2、成员方法(代表行为，一般是动词)
    3、构造器
    4、代码块
    5、内部类
}

例如以下：
public class Phone {
    //属性(成员变量)
    String brand;
    double price;
    int age = 0;
    
    //行为(方法)
    public void call(){
    
    }

    public void playGame(参数){
        方法体语句;
        return语句;
    }
}

（3）、如何得到类的对象。

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

例如以下：
Phone p = new Phone();

（4）、如何使用对象。

1、访问属性：
对象名.成员变量 = 值;    //为成员变量赋值
对象名.成员变量;    //访问成员变量的值



2、访问行为：
对象名.方法名(实际参数);

（5）、设计对象并使用举例

package test;

public class Phone {
    //属性
    String brand;
    double price;

    //行为
    public void call(){
        System.out.println("手机在打电话");
    }
    public void playGame(){
        System.out.println("手机在玩游戏");
    }

}

package 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();
    }

}

（6）、定义类的补充注意事项

a、类名首字母建议大写，用英文，需要见名知意，驼峰模式。不能用关键字，满足标志符规定。

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

c、成员变量的完整定义格式是：

修饰符 数据类型 变量名称 = 初始化值;

一般无需指定初始化值。存在默认值，默认值如下：

 （7）、练习题（女朋友类）

编写女朋友类，创建女朋友类的对象，给女朋友的属性进行赋值并调用女朋友类中的方法。

package test02;

public class GrilFriend {
    //属性
    String name;
    int age;
    String gender;

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

package test02;

public class GrilFriendTest {
    public static void main(String[] args) {
        GrilFriend gf1 = new GrilFriend();
        gf1.name = "小红";
        gf1.age = 18;
        gf1.gender = "温柔";
        System.out.println(gf1.name);
        System.out.println(gf1.age);
        System.out.println(gf1.gender);
        gf1.sleep();
        gf1.eat();

        System.out.println("==============");
        GrilFriend gf2 = new GrilFriend();
        gf2.name = "小花";
        gf2.age = 19;
        gf2.gender = "可爱";
        System.out.println(gf2.name);
        System.out.println(gf2.age);
        System.out.println(gf2.gender);
        gf2.sleep();
        gf2.eat();
    }
}

扩展：选中内容，按住滚轮，往下拖，就可选中同一竖行的字母，进行同时修改

2、封装

1、对象代表什么，就得封装对应的数据，并提供数据对应的行为。

private关键字

（1）、是一个权限修饰符

（2）、可以修饰成员（成员变量和成员方法）

（3）、被private修饰的成员只能在本类中才能直接访问。在当前类之外，是不能直接被访问的。保证数据的安全性，不传递非法数据。

（4）、针对private修饰的成员变量，如果需要被其他类使用，需要提供相应的操作。

（5）、提供“setXxx(参数)”方法，用于给成员变量赋值，方法要用public修饰。

属性赋值的格式:  
public void set+首字母大写的变量名(数据类型 参数名){
 	变量名 = 参数名;
}

例如：
public void setName(String n){
 	name = n;
}

（6）、提供“getXxx()”方法，用于获取成员变量的值，方法要用public修饰。

属性值获取的格式：
public 返回值类型 get+首字母大写的变量名(){
 	return 变量名;
}

例如：
public String getName(){
 	return name;
}

（7）、private可以修饰的内容有：成员变量、成员方法、构造方法、内部类。

例如：

public class GrilFriend {
    private String name;
    private int age;
    private String gender;
}

前面加上private后，测试类main方法在访问的时候，系统就会报错。

2、如何让实现封装

具体的实现过程是，在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在的类中被访问，如果外界想要访问私有属性，需要提供一些public修饰的公有方法，其中包含用于获取属性值的getXxx()方法 和 设置属性值的setXxx()方法。

package test02;

public class GrilFriend {
    //属性
    private String name;
    private int age;
    private String gender;
    //针对于每一个私有化的成员变量，都要提供get和set方法
    //set方法：给成员变量赋值
    //get方法：对外提供成员变量的值

    //作用：给成员变量name进行赋值
    public void setName(String n){ //无返回值类型，所以用void
        name = n;
    }
    //作用：对外提供name属性
    public String getName(){    //return返回值类型为String
        return name;
    }

    //age
    //setAge：给成员变量age进行赋值
    //getAge：对外提供成员变量age的值
    public void setAge(int a){ //无返回值类型，所以用void
        if(a >= 18 && a <= 50){
            age = a;
        } else {
            System.out.println("非法参数");
        }
    }
    public int getAge(){    //return返回值类型为int
        return age;
    }

    //gender
    public void setGender(String g){ //无返回值类型，所以用void
        gender = g;
    }
    public String getGender(){    //return返回值类型为String
        return gender;
    }

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

package test02;

public class GrilFriendTest {
    public static void main(String[] args) {
        GrilFriend gf1 = new GrilFriend();
        //赋值
        gf1.setName("小红");
        gf1.setAge(18);
        gf1.setGender("温柔");

        String gf1name = gf1.getName();
        System.out.println(gf1name);
        System.out.println(gf1.getAge());
        System.out.println(gf1.getGender());

        gf1.sleep();
        gf1.eat();

    }
}

3、补充内容

public	公开的，任意类皆可访问，不推荐，违背了封装
protected	受保护的，本类，子类，同包皆可访问
private	私有化，本类可访问，子类也不能访问
default(默认值)	同包中可以访问

3、就近原则和this关键字

3.1、 就近原则：
① 当访问某个变量的时候，会在访问这条语句所在的大括号中寻找，有没有定义此变量，如果找到了就用，如果没有找到，就会到括号外去寻找，如果找到了就用，找不到就报错
② 当成员变量和局部变量同名的时候，访问变量就看谁距离访问的这个语句更近，就使用谁的数据
3.2、 this关键字
① 表示本类当前对象的引用
② 哪个对象调用this所在的方法，this就表示哪个对象
③ 作用：可以区分同名的成员变量和局部变量，this.变量名 代表访问的是成员变量，不加this的一般都是局部变量

3.3、成员变量和局部变量（遵循就近原则）

public class GrilFriend{
    private int age = 15;
    public void method(){
        int age = 10;
        System.out.println(age);    //输出结果为10
        System.out.println(this.age);    //输出结果为15
    }
}

添加this后访问的是成员变量，不添加this访问时遵循就近原则，访问局部变量
this用来区分成员变量和局部变量

package test02;

public class GrilFriend {
    //属性
    private String name;
    private int age;
    private String gender;
    
    public void setName(String name){ 
    //等号右边，局部变量，表示测试类中调用方法传递过来的数据
    //等号的左边，表示成员位置的name
        this.name = name;
    }
    public String getName(){    
        return name;
    }

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

    public void setGender(String gender){ 
        this.gender = gender;
    }
    public String getGender(){    
        return gender;
    }

}

4、构造方法

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

1、构造方法的格式：

public class Student{

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

}

特点：
1、方法名和类名相同，大小写也要一致。
2、没有返回值类型，连void都没有。
3、没有具体的返回值(不能由return带回结果数据。构造方法可以有return，但是只能写  return;  表示结束方法)
4、修饰符可以是public、private，private修饰的就是私有的构造方法，public修饰的就是公开的构造方法

举例如下：
public class Student{
    private String name;
    private int age;

    public Student(){
    //空参构造方法
    }
    
    public Student(String name,int age){
    //带全部参数构造方法
    }

}

执行时机：
1、创建对象的时候由虚拟机调用，不能手动调用构造方法。
2、每创建一次对象，就会调用一次构造方法。
3、不能使用对象名调用构造方法。

2、举例如下：

package test02;

public class GrilFriend {
    private String name;
    private int age;

    //如果我们自己没有写任何构造方法，虚拟机会给我们一个无参数的构造
    //无参数的构造
    public GrilFriend(){
        System.out.println("我有没有被执行呢");
    }
    //有参数的构造
    public GrilFriend(String name,int age){
        this.name = name;
        this.age = age;
    }


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

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

        //set和构造方法的区别
        //set方法主要用于创建对象完成之后，后期修改对象的属性值
        //构造方法主要是创建对象的同时，给对象赋值属性值

}

package test02;

public class GrilFriendTest {
    public static void main(String[] args) {
        //创建对象调用无参数的构造
        GrilFriend gf1 = new GrilFriend();
        gf1.setName("小红");
        gf1.setAge(25);
        System.out.println(gf1.getName());
        System.out.println(gf1.getAge());

        //调用有参数的构造
        GrilFriend gf2 = new GrilFriend("小丽",23);
        System.out.println(gf2.getName());
        System.out.println(gf2.getAge());

    }
}


输出结果为：
我有没有被执行呢
小红
25
小丽
23

3、构造方法注意事项：

1、构造方法的定义
如果没有构造方法，系统将会给出一个默认的无参数构造方法。
如果定义了构造方法，系统将不再提供默认的构造方法。
2、构造方法的重载
带参构造方法，和无参构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载。
3、推荐使用的方式
无论是否使用，都手动书写无参构造方法，和带全部参数的构造方法。
4、一般的类中，既要有空参构造，也要有全参构造，都是手动定义出来的

4、小结

1、构造方法的作用？
  创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的。
2、构造方法有几种？各自的作用是什么？
  无参数构造方法：初始化对象时，成员变量的数据均采用默认值。
  有参数构造方法：在初始化对象的时候，同时可以为对象进行赋值。
3、构造方法有哪些注意事项？
  任何类定义出来，默认就自带了无参构造器，写不写都有。
  一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写无参数构造器了。
  建议在任何时候都手动写上空参和带全部参数的构方法。

5、标准的Javabean类

1、类名需要见名知意。

2、成员变量使用private修饰。

3、提供至少两个构造方法。（无参构造方法；带全部参数的构造方法）

4、成员方法。

        提供每一个成员变量对应的setXxx()/getXxx()

        如果还有其他行为，也要写上。

package test03;

public class User {
    //属性
    private String username;
    private String password;
    private String email;
    private String gender;
    private int age;

    //空参
//快捷方式：Alt+insert->constructor(构造函数)->select None(取消选择)
//快捷方式也可以为Alt+Fn+insert
    public User() {
    }

    //带全部参数的构造
//快捷方式：Alt+insert->constructor(构造函数)->Ctrl+A全选->OK
//快捷方式也可以为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;
    }

    //getXxx()和setXxx()方法
//快捷方式：Alt+insert->Getter and Setter->Ctrl+A全选->OK
//快捷方式也可以为Alt+Fn+insert
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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


/**补充：插件PTG 1秒生成Javabean
 * file->setting->plugins->Marketplace->搜索ptg->OK
 * 在代码书写界面，右击鼠标，选择Ptg To JavaBean进行点击即可
 * 会同时生成空参构造、全参构造、get和set方法
 */

Javabean相关的快捷方式：

1、生成空参构造方法
//快捷方式：Alt+insert->constructor(构造函数)->select None(取消选择)
//快捷键也可以为Alt+Fn+insert
    

2、生成带全部参数的构造
//快捷方式：Alt+insert->constructor(构造函数)->Ctrl+A全选->OK
//快捷键也可以为Alt+Fn+insert
    
3、生成getXxx()和setXxx()方法
//快捷方式：Alt+insert->Getter and Setter->Ctrl+A全选->OK
//快捷键也可以为Alt+Fn+insert
    

4、补充：插件PTG 1秒生成Javabean
 * file->setting->plugins->Marketplace->搜索ptg->OK
 * 在代码书写界面，右击鼠标，选择Ptg To JavaBean进行点击即可
 * 会同时生成空参构造、全参构造、get和set方法
 

6、三种情况的对象内存图

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

8、this的内存原理

9、成员和局部

成员变量的初始化值默认如下：

引用数据类型:    null
整数    0
小数    0.0
字符    \u0000
布尔    false

后续内容仅粉丝可见，请关注后查看