2020-09-20

Day03

封装

1. 该露的露，该藏的藏
   1. 我们程序设计要追求 “高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
2. 封装（数据的隐藏）
   1. 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
3. 记住这句话就够了：属性私有，get/set

//封装的例子
public class Student {
    //属性私有
    private String name;//名字
    private int age;//年龄
    private char sex;//性别
    private int id;//学号

    //提供一些可以操作这个属性的方法
    //提供以下public的 get 、set 方法

    //get 获得这个数据
    public String getName() {
        return name;
    }

    //给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

//通过类中给出的操作接口给对对象进行使用
  /*
    封装的作用：
        1.提高程序的安全性、保护数据。
        2.隐藏代码的实现细节.
        3.统一接口.
        4.系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("小韩");

        System.out.println(s1.getName());

        s1.setAge(119);
        System.out.println(s1.getAge());

    }
}

继承

1. 继承的本质就是对一批类的抽象，从而实现对现实世界更好的建模。
2. extends的意思就是 “扩展”。子类是父类的扩展。
3. Java中类只有单继承，没有多继承。
4. 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
5. 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
6. 子类和父类之间，从意义上讲应该具有 “is a “ 的关系。

//eg:
//在Java中，所有的类都默认直接或者间接继承Object类
//Person    人
public class Person {

    //public
    //protected
    //default
    //private
        /*
        如果父类的属性使用了private（私有的）修饰，那么如果子类想要
        使用或者得到该属性的话，就应该通过可行的接口（方法）获得，这
        时父类就要给出方法给予子类调用获得属性值。
         */

    private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void say(){
        System.out.println("父类会说话相当于子类也会说话！");
    }

}

//学生    is  人   ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
}

//老师    is  人   ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Teacher extends Person{
}

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

        Student s1 = new Student();
        s1.say();
        System.out.println(s1.getMoney());

    }

}

super关键字 - this关键字

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个。
2. super必须只能出现在子类的方法或者构造方法中！
3. super 和 this 不能同时调用构造方法！

super vs this：

1. 代表的对象不同：
   1. ​ this：本身调用者这个对象
   2. ​ super：代表父类对象的引用
2. 前提：
   1. this：没有继承也可以使用
   2. super：只有在继承条件下才可以使用
3. 构造方法：
   1. this();本类的构造
   2. super();父类的构造

//eg:
public class Person {

    public Person(){
        System.out.println("Person无参执行了！");//Person无参执行了！
    }

    protected String name = "xiaohan";

    public void print(){
        System.out.println("父类的print方法！");
    }

}
public class Student extends Person {

    public Student(){
        //隐藏代码：调用父类的无参构造器
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了！");//Student无参执行了！
    }

    private String name = "小韩";

    public void test(String name){
        System.out.println(name);//xh
        System.out.println(this.name);//小韩
        System.out.println(super.name);//xiaohan
    }

    public void print(){
        System.out.println("子类的print方法！");
    }

    public void test1(){
        print();//子类的print方法！
        this.print();//子类的print方法！
        super.print();//父类的print方法！
    }

}
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

//        s1.test("xh");
//
//        s1.test1();
    }
}

方法重写

重写：需要有继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public>protected>default>private
4. 抛出的异常：范围可以缩小但不能扩大

重写：子类的方法和父类必须一致，方法体不同！

为什么需要重写：

1. 父类的功能，子类不一定需要，或者不一定满足！
2. alt + insert ：override

//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B==>test()");
    }
}
//继承
public class A extends B {

    @Override//重写
    public void test() {
        System.out.println("A==>test()");
    }
}
public class Application {
    public static void main(String[] args) {

        A a = new A();
        a.test();//A==>test()

        //父类的引用指向了子类
        B b = new A();
        b.test();//A==>test()

    }
}

多态

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多

多态的注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系，类型转换异常！ClassCastException!
3. 存在条件
   1. 继承关系
   2. 方法需要被重写
   3. 父类引用指向子类对象（Father f = new Son();）

被以下关键字修饰的方法是不能被重写的：

1. static 方法，属于类，不属于实例
2. final 方法，属于常量
3. private 方法

public class Person {

    public void run(){
        System.out.println("人在跑步!");
    }
}
public class Student extends Person {

    @Override
    public void run() {
        System.out.println("学生在跑步！");
    }

    public void eat(){
        System.out.println("学生在吃饭！");
    }
}
public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
//        new Student();
//        new Person();

        //可以指向的引用类型就不确定了：父类的引用指向子类
        //Student 子类能调用的方法都是自己的或者继承父类的方法！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法，比如说eat()方法！
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        //如果左边是父类的引用指向了子类===》如果子类重写了父类的方法，那么执行子类重写后的方法
        //                         ===》如果没有父类的方法没有被子类重写，那么执行父类本身的方法
        s1.run();
        s2.run();

        s1.eat();

    }
}

instanceof （引用类型转换）

//Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        Object object = new Student();

//        System.out.println(X instanceof Y);//instanceof===>判断X 和 Y 是否有子父类引用关系
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=======================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//编译报错！
        System.out.println("=======================");

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//编译报错
//        System.out.println(person instanceof String);//编译报错！

总结：

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型。（可能会丢失自己本身的一些方法）
3. 把父类转换为子类，向下转型；需要强制转换。
4. 方便方法的调用，减少重复的代码！简洁！

static关键字

静态变量 与 非静态变量

public class Studnet {

    private static int age;//静态的变量
    private double score;//非静态的变量

    public static void main(String[] args) {
        Studnet s1 = new Studnet();
        //因为 age 是static修饰的静态变量，是随着类加载而加载的，不属于实例，但是也可以通过实例的方式进行调用
        System.out.println(Studnet.age);
        System.out.println(s1.age);
        //因为score是一个非静态变量，属于实例，所以应该通过实例的方式进行调用！
        System.out.println(s1.score);
    }
}

静态方法

public class Studnet {

    public void run(){
        go();
    }
    public static void go(){
        System.out.println("go!");
    }
    

    public static void main(String[] args) {
        go();
    }
}

匿名代码块 & 静态代码块 & 构造器

区别：匿名代码块 和 构造器 可以执行多次，而 静态代码块 只执行一次！

public class Person {

    //2：可以用于赋初值
    {
        System.out.println("匿名代码块！");
    }
    //1:静态代码块：只执行一次
    static {
        System.out.println("静态代码块！");
    }
    //3：构造器
    public Person(){
        System.out.println("构造器方法！");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("===========");
        Person person1 = new Person();
    }

}
//运行结果：
静态代码块！
匿名代码块！
构造器方法！
===========
匿名代码块！
构造器方法！

静态导入包

实现如下：

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {

    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
    
}

abstract

//abstract 抽象类
public abstract class Action {

    //约束~有人帮我们实现！
    //abstract 抽象方法，只有方法名字，没有方法的实现，方法的实现由其他（子类）进行实现！
    public abstract void doSomething();
    
    //1.抽象类不能 new 出来，只能靠子类去实现它；约束！
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中！
    //抽象的抽象：约束！
    
    //存在的意义：抽象出来---》提高开发效率

}
//继承了抽象类的子类，必须实现所有抽象类中的抽象方法，如果子类也是抽象的话，那么就是子子类进行实现继承中抽象类的所有抽象方法！
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

思考题：抽象类不能被 new ,那么它存在构造器吗？

答：存在构造器的，接口是我们常用的，抽象类好像并不是怎么常用，但这并不代表他不重要，他可以被继承，可以有构造方法，可以给类中的成员变量赋初值，接口就没有这样的功能。
抽象类的出现使得位于上层的类更具有通用性。从某种角度来看，祖先类更加具有通用性。
普通类加abstract即为抽象类。抽象类不能够被实例化，也就是说我定义了一个抽象类public abstract class Person{...}类，这个person类不能被new；大家也都知道，在new的时候是调用了构造方法，既然抽象了不能够被new为什么还要有构造方法？世界之大，无奇不有，这个方法行不通我们就想另一种方法，我们可以通过new，可以通过set、get方法给成员属性赋值，我们还可以在子类中调用super()方法给父类赋初值，然后继承父类当中的属性，既然不能通过new来调用抽象类的构造方法，我们可以看到还可以通过子类的super()方法来调用抽象类的构造方法，并对其赋值，例如我编写了一个Student类，继承于抽象类Person，public class Student extents Person{...}，Student类可以被实例化，要想对Person类中的某些成员方法赋初值，可以在Student类中调用super()方法，对抽象类的成员属性进项赋值，继承了抽象类的子类就可以对抽象类的一些属性进行赋值，并且可以继承抽象类已经赋值过的方法和属性。
需要注意的是，还可以定义一个抽象类的对象变量，但是他只能引用非抽象类子类的对象。例如，Person p = new Stduent(“张三”,28);这里的p是一个抽象类Person的变量，Person引用了一个非抽象子类Student的实例。
抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类，在抽象类中的抽象方法可以只定义，空实现，但是实现了抽象类的子类必须要重写实现抽象类中的抽象方法。

接口（interface）

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范！自己无法写方法_{专业的约束！约束和实现分离：面向接口编程}

接口就是规范，定义的是一组规则，体现了现实世界中 “如果你是…则必须能…“ 的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。

接口的本质是 契约。就像我们人间的法律一样，制定好后大家遵守！

接口是OO的精髓，是对 对象 的抽象，最能体现这一点的就是接口。

public interface UserService {

    //常量~public static final
    int age = 20;


    //接口中的所有定义其实都是抽象的   public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}
public interface TimeService {
    void timer();
}
//抽象类：extends~
    //类 可以实现接口  implements 接口
    //类实现了接口，就需要重写接口中所有的方法~
    //利用接口实现多继承~
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口作用总结：

1. 约束！
2. 定义一些方法，让不同人实现~
3. 接口中定义的所有方法都是抽象的 public abstract
4. 接口中定义的所有变量都是常量 public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

内部类

//外部类
public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    //内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法！");
        }
        //内部类可以获得外部类的私有属性,私有方法
        public void getId(){
            System.out.println(id);
        }
    }

}
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//这是内部类的方法！
        inner.getId();//10
    }
}

匿名类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        //实现了接口的类
        UserService userService = new UserService(){

            @Override
            public void hello() {
                
            }
        };
    }
}
//一个Java类中可以有多个class类，但是只能有一个 public class类
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

interface UserService{
    void hello();
}

异常机制

异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

异常发生在程序运行期间，它影响了正常程序执行流程。

异常处理机制

1. 抛出异常
2. 捕获异常
3. 异常处理五个关键字（try、catch、finally、throw、throws）

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        
        //假设要捕获多个异常：从小到大！

        try {//try监控区域
            System.out.println(a / b);
        } catch (Error e) {//catch（想要捕获异常的类型）捕获异常
            System.out.println("ERROR!");
        } catch (Exception e) {
            System.out.println("Exception!");
        } catch (Throwable e) {
            System.out.println("Throwable!");
        } finally {//处理善后工作！
            System.out.println("finally!");
        }
        //finally可以不要，但是一定会执行，一般在IO , 资源关闭上会广泛使用！
    }
}

 //假设这个方法中，处理不了这个异常，方法上抛出异常
    public void test (int a ,int b) throws ArithmeticException{
        if (b == 0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
    }
  try {
            new Test().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
        }

自定义异常

public class MyException extends Exception {

    //传递数字  > 10
    private int detail;

    public MyException(int a){
        this.detail = a;
    }

    //toString:异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}
public class Test {
    static void test(int a) throws MyException{
        System.out.println("传递的参数为：" + a);

        if (a > 10){
            throw new MyException(a);
        }
        System.out.println("OK!");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException=>" + e);
        }
    }
}

实际应用中的经验总结：

1. 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
2. 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常
4. 尽量去处理异常，切记只是简单地调用printStackTrace（）去打印输出
5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定
6. 尽量添加finally语句块去释放占用资源，IO流等

常用类

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层。

Object类中定义的方法，是所有对象都具备的方法。

Object类型可以存储任何对象

1. 作为参数，可接受任何对象。
2. 作为返回值，可返回任何对象。

getClass()方法

返回引用中存储的实际对象类型。

应用：通常用于判断两个引用中实际存储对象类型是否一致！

public class Student {

    private String name;
    private int 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;
    }
}
public class TestGetClass {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1.getClass().equals(s2.getClass()));//true==>说明s1 和 s2属于同一类型
    }
}

hashCode()方法

返回该对象的哈希码值，哈希值是根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。

一般情况下相同对象返回相同哈希码。

public class TestHashCode {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());

    }
}