Java基础——面向对象高级（包、抽象类、接口、多态）

一、包

        1.包本质来说就是文件夹,  用来管理类文件的
        2.建包
           建包的语法格式：package 公司域名倒写.技术名称。报名建议全部英文小写，且具备意义
                                        package com.companyname.domain; public class Student { }
           建包语句必须在第一行，一般IDEA工具会帮助创建
           idea中创建包
           
         3.导包 
           相同包下的类可以直接访问，不同包下的类必须导包,才可以使用！
           导包格式：import 包名.类名;
            假如一个类中需要用到不同类，而这个两个类的名称是一样的，那么默认只能导入一个
            类，另一个类要带包名访问。

二、抽象类

        抽象类是一种特殊的父类，内部可以编写抽象方法
                public class parent {     public void par(); }
                public class son extends parent {    
                        @Override    
                         public void par() {         System.out.println("子级重定义！");     }
                }
        抽象方法：将共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑 无法在父类中给
                          出具体明确的值或是逻辑，该方法就可以定义为抽象方法。
        抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。
        抽象方法的定义格式： public abstract 返回值类型 方法名(参数列表);

        abstract class Animal { public abstract void eat(); }

        抽象类的定义格式： public abstract class 类名{}
        注：
        抽象类不能实例化
        抽象类存在构造方法
        抽象类中可以存在普通方法
        抽象类的子类 要么重写抽象类中的所有抽象方法 要么是抽象类
        abstract 关键字的冲突：
        final：被 abstract 修饰的方法，强制要求子类重写，被 final 修饰的方法子类不能重写         private：被 abstract 修饰的方法，强制要求子类重写，被 private 修饰的方法子类不能重写         static：被 static 修饰的方法可以类名调用，类名调用抽象方法没有意义

三、接口
        1.接口：体现的思想是对规则的声明     Java中的接口更多体现的是对行为的抽象

        2.接口介绍：
        接口用关键字interface来定义 public interface 接口名 {}
        接口不能实例化
        接口和类之间是实现关系，通过implements关键字表示
        public class 类名 implements 接口名 {}
        接口的子类（实现类） 要么重写接口中的所有抽象方法 要么是抽象类（很少用）；
        interface Inter {
                public abstract void show();
                public abstract void method();
        }

        class InterImpl implements Inter {
                @Override
                public void show() {
                        System.out.println("show...");
                }
                @Override
                public void method() {
                        System.out.println("method...");
                }
        }

        3.接口中的成员特点
           成员变量 只能是常量 默认修饰符：public static final
           构造方法 没有
           成员方法 只能是抽象方法 默认修饰符：public abstract 

·        4.类和接口之间的各种关系
            类和类的关系 继承关系，只能单继承，但是可以多层继承
            类和接口的关系 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现
                                        多个接口
             接口和接口的关系 继承关系，可以单继承，也可以多继承

        5.抽象类和接口的对比
            成员变量 :
                抽象类 : 可以定义变量, 也可以定义常量
                接口 : 只能定义常量
            成员方法
                 抽象类 : 可以是定义具体方法, 也可以定义抽象方法
                 接口 : 只能定义抽象方法
             构造方法
                 抽象类 : 有
                 接口 : 没有
             

四、多态

        多态：同一个行为具有多个不同表现形式或形态的能力
        多态前提：①有继承 / 实现关系；②有方法重写；③有父类引用指向子类对象；
        多态的成员访问特点:
                成员变量：编译看左边（父类），执行看左边（父类）
                成员方法：编译看左边（父类），执行看右边（子类）
                class Fu {
                        int num = 10;
                        public void show() {
                                System.out.println("Fu...show");
                        }

                        public static void print(){
                                System.out.println("Fu...print");
                        }
                }

                class Zi extends Fu {
                        int num = 20;

                        @Override
                        public void show() {
                                System.out.println("Zi...show");
                       }

                        public static void print(){
                                System.out.println("Zi...print");
                        }
                }

                //主方法调用

                Fu f = new Zi();
                System.out.println(f.num); // 10
                f.show();  // Zi...show
                f.print();   // Zi...print

        多态创建对象, 调用静态成员 :
                静态的成员, 推荐类名进行调用
                注: 静态的成员, 可以使用对象名调用, 但这是一种假象
                        - 生成字节码文件后, 会自动将对象名调用, 改成类名调用

         多态的好处 ：提高了程序的扩展性
                ① 对象多态 : 将方法的形参定义为父类类型, 这个方法可以接收该父类的任意子类对象
                                      Animal a1 = new Dog();
                                      Animal a2 = new Cat();
                ② 行为多态 : 同一个行为, 具有多个不同表现形式或形态的能力        
        多态的弊端：不能使用子类的特有成员
        多态中的转型：
                向上转型     从子到父（父类引用指向子类对象）
                                    Parent  f = new Son();
                向下转型     从父到子（将父类引用所指向的对象, 转交给子类类型）
                                    Son s = (Son) f;                

        案例：
                某网站需要开发一个支付功能，需要支持多种支付方式 (支付平台支付、银行卡网银支
                付、信用卡快捷支付)，如下所示：
                        请选择支付方式:1、支付平台支付 2、银行卡网银支付 3、信用卡快捷支付
                        请输入您的支付方式:2
                        请输入您的支付金额: 56.78
                        通过银行卡网银支付了: 56.78元!
                        //接口
                        public interface Payment {
                                void pay(double money);
                        }
                        //银行卡支付类
                         public class BankcardPaymentImpl implements Payment{
                                @Override
                                public void pay(double money) {
                                        System.out.println("通过银行卡网银支付了:" + money + "元!");
                                  }
                            }
                         //支付平台支付类
                         public class PlatformPaymentImpl implements Payment {
                                @Override
                                public void pay(double money) {
                                        System.out.println("通过支付平台支付了:" + money + "元!");
                                }
                        }
                        //信用卡支付类
                        public class CreditCardPaymentImpl implements Payment {
                                @Override
                                public void pay(double money) {
                                        System.out.println("通过信用卡快捷支付:" + money + "元!");
                                 }
                          }
                        //测试类
                        public static void main(String[] args) {
                                Scanner sc = new Scanner(System.in);
                                System.out.println("请选择支付方式: 1. 支付平台支付 2. 银行卡网银支付 3. 信
                                用卡快捷支付");
                                int choice = sc.nextInt();
                                Payment payment = null;
                                switch (choice) {
                                        case 1 :
                                                payment = new PlatformPaymentImpl();
                                                break;
                                        case 2:
                                                payment = new BankcardPaymentImpl();
                                                break;
                                        case 3:
                                                payment = new CreditCardPaymentImpl();
                                                break;
                                 }

                                System.out.println("请输入您的支付金额: ");
                                  double money = sc.nextDouble();
                                   payment.pay(money);
                        }

        ClassCastException问题：（常见在父类转子类中）
                如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的
                时候就会出现ClassCastException
        解决：
        关键字 instanceof 使用格式：
                 对象名 instanceof 类型 判断一个对象是否是一个类的实例
                通俗的理解：判断关键字左边的对象，是否是右边的类型，返回boolean类型结果