day09(面向对象1）

权限修饰符

//package com.atguigu.encapsulability;
1、权限修饰符有哪些？
public、protected、private三个单词。
可见性范围分为四种情况：
            本类      本包的其他类      其他包的子类中     其他包的非子类
private      √          ×               ×               ×
缺省          √          √              ×               ×
protected    √           √              √              ×
public       √           √              √               √

2、权限修饰符的使用要注意
（1）如果权限修饰符是在class前面（这里暂不讨论内部类），只能是public或缺省
（2）如果权限修饰符是在类的成员前面（成员变量，成员方法等），四种都可以

属性私有化和get、set方法

student.java
TestField.java

package com.atguigu.encapsulability;

public class Student {
    private String name;
    private int score;
    private int age;
    private boolean marry;

/*    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }*/
    //快捷键，自动生成get/set
    //在要写get/set方法的位置，鼠标的光标不要定位错位置了
    //按快捷键 Alt + Insert，部分同学需要同时按Fn
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        //加条件判断，加逻辑的控制
        if(age<=20 || age>=35){
            return;
//            throw new IllegalArgumentException(age +"非法");
        }
        this.age = age;
    }
    public boolean isMarry() {
        return marry;
    }
    public void setMarry(boolean marry) {
        this.marry = marry;
    }
}


package com.atguigu.encapsulability;

二、成员变量选择哪种权限修饰符？
1、实际应用中，习惯上，先声明为private。称为属性私有化。
但是如果确实这个成员变量需要扩大它的可见性范围，那么可以把private修改为其他合适的修饰符。
例如：扩大到本包，那么就是缺省的
例如：扩大到其他包的子类中，那么就是protected
例如：扩大到任意位置，那么就是public

2、为什么？
因为属性其实就是代表对象的“数据”，那么对象的数据是非常重要的，不应该完全暴露，至少要可控。

3、演示

4、如何使用私有化的属性
如果这个属性确实要被外部使用，需要提供get或set方法。
get方法：供调用者获取属性值的方法
set方法：供调用者修改属性值的方法

5、get/set方法要注意的地方
（1）如果方法中有局部变量（通常是形参）与对象的实例变量“重名”，
那么需要在实例变量的前面加"this.“，
如果没有重名问题，在实例变量前面可以加"this.”，也可以不加"this.“

（2）get/set的方法名，通常都是
get + 属性名，并且属性名的首字母大写
set  + 属性名，并且属性名的首字母大写

（3）如果属性（实例变量）是boolean类型，
那么它对应的get方法，就会把get单词换成is。

public class TestField {
    public static void main(String[] args) {
        Student s1 = new Student();
/*        s1.name = "张三";
        s1.score = 89;
        s1.age = 23;
        //以上代码正常使用没问题，但是如果出现以下代码
        s1.score = -89;
        s1.age = -23;
        //这样写，逻辑上有问题，语法上没法控制*/

        //这里是调用者的角色，调用s1学生对象的姓名name的get和set
        System.out.println("修改之前，姓名：" + s1.getName());
        s1.setName("张三");
        System.out.println("修改之后，姓名：" + s1.getName());

        System.out.println("修改之前，年龄：" + s1.getAge()) ;
        s1.setAge(-23);
        System.out.println("修改之后，年龄：" + s1.getAge()) ;
    }
}

外部类要跨包使用必须是public，否则仅限于本包使用

外部类的权限修饰符如果缺省，本包使用没问题

外部类的权限修饰符如果缺省，跨包使用有问题

成员的权限修饰符问题

(1)本包下使用：成员的权限修饰符可以是public、protected、缺省

(2)跨包下使用：要求严格

(3)跨包使用时，如果类的权限修饰符缺省，成员权限修饰符>类的权限修饰符也没有意义

方法重写

我们说父类的所有方法子类都会继承，但是当某个方法被继承到子类之后，子类觉得父类原来的实现不适合于子类，该怎么办呢？我们可以进行方法重写 (Override)

1、方法重写

Phone.java

package com.atguigu.inherited;

public class Phone {
    protected String name;
    protected double price;

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNumber(){
        System.out.println("显示来电号码");
    }

    protected Person getOwner(){
        return new Person();//具体功能省略了
    }
}

Smartphone.java

package com.atguigu.inherited;

/*
智能手机子类，关于来电显示号码这个功能有改进，不仅仅显示号码，
可以显示头像，姓名/来电地区等
 */
//Smartphone：智能手机
public class Smartphone extends Phone {

    public void showFunction(){
        sendMessage();
        call();
        showNumber();
    }

    @Override
    public void showNumber() {
        //重写的意思，就是重新实现这个方法，就是重新编写方法体
        System.out.println("显示头像");
        System.out.println("显示名称等");

        //想要继续保留父类被重写的功能：显示来电号码
        super.showNumber();
    }

    //这个是用于注释，标记，该方式是子类重写父类的方法，不是子类自己扩展的方法
    //如果去掉@Override，对于代码执行来说，没有任何影响，但是会影响一些代码的编译
    //在重写的方法上面保留@Override，可以让编译器帮你检查是否满足重写的种种要求。
    @Override
    public Father getOwner() {
        return new Father();
    }

    public String getInfo(){
       // return "手机名称：" + name + "，价格：" + price;//因为父类中的name和price是private
        return "手机名称：" + getName() + "，价格：" + getPrice();
    }
}

TestOverride.java

package com.atguigu.inherited;

1、方法的重写（Override）
当子类对从父类继承的方法实现（方法体）不满意时，
或者说，子类对某个方法的实现有更进一步的改良，
子类完全可以重写/覆写这个方法。

2、IDEA中如何重写父类的某个方法呢？
光标定位在子类要写方法的位置，按快捷键。
快捷键：Ctrl + O

3、当通过子类对象调用重写的方法时，肯定是执行重写后的代码。

4、当在子类重写方法的方法体中，想要继续执行
父类被重写方法的方法体时，
可以通过“super.父类被重写方法名(..)"

5、重写方法有要求：
（1）方法名：必须相同
（2）形参列表：必须相同
（3）返回值类型：
    基本数据类型和void，必须相同
    引用数据类型：<=
           Java中的子类<父类，这个是从类表示的事物范围角度来说的。

子类重写的方法的返回值类型可以和父类被重写方法的返回值类型一样。
子类重写的方法的返回值类型可以是父类被重写方法的返回值类型的子类。
（4）权限修饰符：
首先，子类要重写父类的某个方法，要求该方法必须在子类是可见。
意味着的private的方法，在子类是不能被重写。
跨包的子类，权限修饰符缺省的方法，在子类中也是不能被重写。

其次，子类重写父类的方法时，权限修饰符必须满足>=的关系

（5）其他要求，等待后面补充
其他修饰符：static,final等
抛出的异常类型等。

对比方法的重载：
    方法名：必须相同
    形参列表：必须不同
    返回值类型：无关

6、重写方法上面强烈建议保留 @Override
这个是用于注释，标记，该方式是子类重写父类的方法，不是子类自己扩展的方法
如果去掉@Override，对于代码执行来说，没有任何影响，但是会影响一些代码的编译检查。
在重写的方法上面保留@Override，可以让编译器帮你检查是否满足重写的种种要求。
 
public class TestOverride {
    public static void main(String[] args) {
        //调用重写后的方法
        Smartphone sp = new Smartphone();

        sp.showNumber();

    }
}