JavaSE之面向对象

面向对象四大特性

抽象:将现实事物或问题抽象成大脑中的概念模型

继承:一个类可以从一个现有的类当中派生出来，派生出来的类称为该类的子类，原有的类称为父类（基类，超类）
子类会拥有父类当中所有的属性和方法，除了：
①私有成员
②构造器
在Java中只支持单继承,一个子类只能有一个直接父类，一个父类可以有任意多个子类
继承的语法
public class A extends(拓展) B{}
继承带来的优点：
是一种代码重用的重要手段，也是实现"开闭原则"的基础，同时子类还可以添加自己独有的属性和方法，来拓展父类功能
开闭原则：对拓展开放，对修改关闭

public class Employee {
    String name;// 名字
    int id;// 工号
    public void code() {
        System.out.println(name+"在工作");
    }
}

public class Manager extends Employee{
    double money;
    public void rest() {
        System.out.println(name+"在休息");
    }
}

public class Test {
    public static void main(String[] args) {
        Manager m = new Manager();
        m.name = "李磊";
        m.code();
        m.rest();   
        Employee e = new Employee();
        e.code();
        Employee e1 = new Manager();
    }
}

子类实例化的过程（创建一个子类对象时，发生了什么）
创建子类对象时，子类构造器会默认调用父类的无参构造器先创建父类对象，之后再创建子类对象
若父类没有无参构造器，子类构造器就必须使用super显式（写代码）调用父类的有参构造器，否则编译出错
super
①super(args)调用父类其他构造器，只能用在子类构造器，第一行，只能用一次
②super.属性名，super.方法名

方法的重写

public class FatherDemo1 {
    int num = 100;
    public void study() {
        System.out.println("父类在努力学习");
    }
}

public class SonDemo1 extends FatherDemo1{
    int num = 20;// 注意属性不存在重写
    String name = "leo";
    public void test() {
        System.out.println("test方法");
    }
    @Override
    public void study() {
        System.out.println(num);
        System.out.println("子类在玩，不咋学习");
    }
}

public class Test1 {
    public Object getNum() {
        return "String";
    }
    public static void main(String[] args) {
//      FatherDemo1 sd = new FatherDemo1();
//      SonDemo1 sd1 = new SonDemo1();
//      sd1.name = "张三";
//      sd1.num = 1;
//      sd1.test();
//      sd1.study();
//      sd.study();// 父类在努力学习  子类在玩，不咋学习
//      System.out.println(sd.num);
        
//      上溯造型（向上转型） ： 父类引用指向子类对象
//      父类引用不能访问子类拓展的属性和方法
//      调用的方法取决于对象类型，不取决于引用类型
        FatherDemo1 sd = new SonDemo1();
        sd.study();
        System.out.println(sd.num);
        
//      下溯造型（向下转型）：子类引用指向父类对象，只有上溯过的才能下溯
        SonDemo1 sd1 = (SonDemo1)sd;
        FatherDemo1 sd2 = sd1;
        FatherDemo1 sd3 = new SonDemo2();
        FatherDemo1 sd4 = sd3;
        
//      判断一个引用指向哪一个类
        if(sd4 instanceof SonDemo1) {
            System.out.println("SonDemo1");
        }
        
        if(sd4 instanceof SonDemo2) {
            System.out.println("SonDemo2");
        }
//      Test1 t = new Test1();
//      String str = (String)t.getNum();
//      System.out.println(str.length());
    }
}

封装:将功能组织到方法中，将属性和方法组织到类中都是封装

访问权限修饰符

JavaBean实体类

public class Demo5 {
    public static void main(String[] args) {
        // Java面相对象特性：继承，封装，多态，抽象
        // 抽象（程序员将现实实物抽象为脑中概念模型）
        // 封装 ：将一套功能组织成一个方法，将一套方法加一套属性组织到一个类，将一套类组织到一个包中
        // 访问权限修饰符
        /*
         * public : 公有，工程中可见
         *      能修饰类，方法，属性（全局变量）
         * protected : 受保护的,当前包可见，跨包的“亲戚(子类)”可见，“非亲戚（非子类）”不可见
         *      能修饰方法和属性
         * 【friendly,default】:默认的，跨包不可见
         *      能修饰类，方法，属性（全局变量）
         * private : 私有的，只有当前类可见
         *      能修饰方法和属性
         */
        // JavaBean(实体类) : 
        // 1.有无参构造器（必要）
        // 2.属性全部私有
        // 3.有公有的get（获取）和set（修改）方法
    }
}

public class Student {
    private int num = 10;
    private int age = 20;
    private String name;
    public void test() {
        System.out.println("测试方法");
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

多态:（一种事物的不用形态，对同一消息做出的不同响应）是一种编程策略
条件：
①要有泛化（继承，实现）关系；
②要有上溯造型（父类引用指向子类对象）；
③要有方法的重写
优点：解耦合（拓展性强，易维护）

public class Customer {
    int id;
    String name;
    public void buy(TrainStation ts) {}
}

public class Student  extends Customer{
    public Student() {}
    public Student(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public void buy(TrainStation ts) {
        System.out.println(name+"是一个学员，打五折，收费"+ts.price*0.5);
    }
}

public class Criminal extends Customer{
    public Criminal() {}
    public Criminal(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public void buy(TrainStation ts) {
        System.out.println(name+"是一个罪犯，打骨折");
    }
}

public class Teacher extends Customer{
    public Teacher() {}
    public Teacher(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public void buy(TrainStation ts) {
        System.out.println(name+"是一个讲师，打八折，收费"+ts.price*0.8);
    }
}

public class TrainStation {
    int price = 100;
    public void saleTicket(Customer c) {
        TrainStation ts1 = this;
        c.buy(ts1);
    }
}

public class Test {
    public static void main(String[] args) {
        Customer s = new Student(1001, "小翟");
        Customer t = new Teacher(9527, "大翟");
        Customer c = new Criminal(1011011, "老翟");
        Customer e = new Employee(1, "老翟1111");
        
        TrainStation ts = new TrainStation();
        ts.saleTicket(s);
        ts.saleTicket(t);
        ts.saleTicket(c);
        ts.saleTicket(e);
    }
}

在Java中多态有哪些体现
重载--编译时多态
重写--运行时多态

接口

public interface News {
    // 发布新闻
    void releaseNews();
}

/**
 * 体育板块
 * @author Administrator
 */
public class Sports implements News{
    @Override
    public void releaseNews() {
        System.out.println("发布了一条体育新闻");
    }
}

/**
 * 娱乐板块
 * @author Administrator
 */
public class Entertainment  implements News{
    public void releaseNews() {
        System.out.println("发布了一条娱乐新闻");
    }
}

/**
 * 政治板块
 * @author Administrator
 */
public class Polity implements News{
    @Override
    public void releaseNews() {
        System.out.println("发布了一条政治新闻");
    }
}

public class TestDemo1 {
    public static void main(String[] args) {
        while(true) {
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入要发布的新闻类型");
            System.out.println("1--------体育新闻");
            System.out.println("2--------政治新闻");
            System.out.println("3--------娱乐新闻");
            System.out.println("4----------退出");
            int num = scan.nextInt();
            // 上溯
            News n = null;
            if(num < 1 || num > 4) {
                System.out.println("无此选项");
            }else {
                switch(num) {
                    case 1:
                        n = new Sports();
                        break;
                    case 2:
                        n = new Polity();
                        break;
                    case 3:
                        n = new Entertainment();
                        break;
                    case 4:
                        System.out.println("再见");
                        return;
                }
                n.releaseNews();
            }
        }
    }
}

抽象类abstract

    public static void main(String[] args) {
        /*
         * final
         * 能修饰类，方法，属性（常量）
         * final类不能被继承
         * final方法不能被子类重写
         * final属性常量，不能改变
         * 
         * abstract抽象
         *  能修饰
         *      类 ：不能实例化（不能创建对象，但是有构造器），它的作用就是做父类
         *      方法:抽象方法，没有方法体,如果一个类中有抽象方法，这个类必须是抽象类
         *  抽象类中可以有非抽象方法
         *  如果一个类继承了一个抽象类，就必须实现父类所有抽象方法，除非这个子类也是抽象类
         */
    }