大数据<javaSE + Linux精英实训班>_day_10

1：基础语法 ->接口
        
        接口是功能的集合，同样可以看做是一种数据类型，是比抽象类更为抽象的类。
        
        接口值描述所应该具备的方法，并没有具体实现。具体的实现由接口的实现（相当于接口的子类）。
        这样价格功能的定义与现实进行了分离，优化了程序设计。
        
        一切事物均有功能，即一切事物均有接口。mvc

package com.itstar.demo01;
/*
 * 定义接口：
 *         使用interface
 * 接口定义：
 *         成员方法，全抽类
 *         不能定义带有方法体的方法
 * 定义抽象方法：固定格式
 *     
 *     public abstract 返回值类型  方法的名字(参数列表);
 * 
 * 接口当中的成员变量的定义：
 *         要求：必须定义为常量
 *         固定的格式：
 *             标准写法
 *         public static final 数据类型  变量名 = 值;
 */
public interface MyInterface {
    // 接口当中的成员变量必须为常量
    public static final int a = 1;
    
    //在接口中，定义抽象方法
    public abstract void function();
}

package com.itstar.demo01;
/*
 *     定义的实现接口，重写接口当中的抽象方法
 * 
 *     类实现接口，可以理解为继承
 * 
 *     关键字:implments 实现
 *  class  类  implements  接口{
 *      重写接口当中的抽象方法
 *  }
 */
public class MyInterfaceIp1 implements MyInterface{

    @Override
    public void function() {
        System.out.println("实现类，重写的抽象方法");
        
    }

}

package com.itstar.demo01;

public class Test {
    public static void main(String[] args) {
        // 创建接口的实现类的对象
        MyInterfaceIp1 imp1 = new MyInterfaceIp1();
        imp1.function(); 
    }
}

 

package com.itstar.demo02;
/*
 * 1.接口中成员变量的特点，没有变量，只有常量
 *      固定的格式：public static final 数据类型  变量名 = 值;
 *             public 权限  最大权限  公有的
 *             static 静态 加了静态的内容可以直接被类名.调用(以前创建对象，用对象来调用)
 *             final 最终  固定住了变量的值  不允许被改值
 *     注意：public static final 属于修饰符 ，在接口中定义省略不写
 *         但是不写不等于没有
 *         还是要写
 * 
 * 2.方法的格式:public abstract 返回值类型  方法名(参数列表)
 *              也可以不写
 *              还是要写
 * 
 * 3.实现类，实现接口，重点接口全部是抽象方法，创建实现类的对象
 *      只有把全部方法重写，才可以用子类对象
 *     
 */
public interface MyInter {
    // 声明一个静态常量
    public static final int a = 1;
    
    void show();
}

package com.itstar.demo02;

public class MyInterImp implements MyInter{

    // 默认权限default
    public void show() {
        
        
    }
    
}

package com.itstar.demo02;

public class Test {
    public static void main(String[] args) {
        int i = MyInter.a;
        System.out.println(i);
        
        
    }
}

 

package com.itstar.demo03;

public interface A {
    public abstract void a();
}

package com.itstar.demo03;

public interface B {
    public abstract void a();
}

package com.itstar.demo03;
/*
 *  类C，同时实现两个接口  接口A B
 *  作为实现类，C，全部重写两个接口的所有抽象方法，才能创建C 的对象
 */
public class C extends D implements A,B{

    @Override
    public void a() {
        
    }

    @Override
    public void d() {
        
    }

}

package com.itstar.demo03;

public abstract class D {
    public abstract void d();
}

 

package com.itstar.demo04;

public interface A {
    public abstract void a();
}

package com.itstar.demo04;

public interface A {
    public abstract void a();
}

package com.itstar.demo04;
/*
 * 接口与接口之间，是继承关系
 * Java支持接口之间的多继承，一个接口可以同时继承多个接口
 */
public interface C extends A,B{
    public abstract void c();
}

package com.itstar.demo04;
/*
 * 问:Java中有多继承吗？
 *     类没有多继承
 *     接口之间有多继承
 */
public class D implements C{

    @Override
    public void a() {
        
    }

    @Override
    public void b() {
        
    }

    @Override
    public void c() {
        
    }

}

 

2：面向对象->多态
    
        多态是继封装、继承之后的，面向对象的第三大特征
        多种形态！
        Java作为面向对象的语言，同样可以描述一个事物的多种形态。
        
        
3：面向对象->多态的定义和使用格式

        父类类型   变量名  = new  子类类型();
        变量名.方法名();

package com.itstar.demo05;

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

package com.itstar.demo05;

public class Cat extends Animal{
    
    
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package com.itstar.demo05;

public class Fu {
    public void show() {
        System.out.println("父类的方法");
    }
}

package com.itstar.demo05;

public interface Smoking {
    public abstract void smoking();
}

package com.itstar.demo05;

public class Student implements Smoking{

    @Override
    public void smoking() {
        System.out.println("学生在抽烟");
    }

}

package com.itstar.demo05;

public class Zi extends Fu{
    public void show() {
        System.out.println("子类重写父类show方法");
    }
}

package com.itstar.demo05;

public class Test {
    public static void main(String[] args) {
        // 公式：父类的类型  变量 = new 子类的对象();
        Fu f = new Zi();
        // 多态调用子类的方法
        f.show();
        
        
        
        // 多态的使用
        Animal a = new Cat();
        a.eat();
        
        // 接口中的多态
        Smoking s = new Student();
        s.smoking();
    }
}

 

package com.itstar.demo06;

public class Fu {
    int a = 1;
    
    public void show() {
        System.out.println("父类的方法");
    }
}

package com.itstar.demo06;

public class Zi extends Fu{
    int a = 3;
    
    public void show() {
        System.out.println("子类的show方法");
    }

package com.itstar.demo06;
/*
 * 多态的特点：
 *     
 *       成员变量：
 *         编译的时候，参考父类中有没有这个变量，如果有编译成功，如果没有编译失败
 *         运行的时候，运行的是父类中的变量值
 * 
 *      成员方法:
 *         编译的时候，参考父类中有没有这个方法，如果有编译成功，如果没有编译失败
 *         运行的时候，运行的是子类重写的方法
 */
public class Test {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.a);
        
        f.show();
    }
}

 

package com.itstar.demo07;

public abstract class Animal {

}

package com.itstar.demo07;

public abstract class Person {
    public abstract void sleep();
}

package com.itstar.demo07;

public class Student extends Person{

    @Override
    public void sleep() {
        System.out.println("学生在写作业");
    }
    
    public void study() {
        System.out.println("学生正在学习");
    }

}

package com.itstar.demo07;

public class Teacher extends Person{

    @Override
    public void sleep() {
        System.out.println("老师在晚睡");
    }

}

package com.itstar.demo07;
/*
 *     运算符比较运算符，结果真假值
 *     关键字：instanceof  以前    ==  >  < ，比较引用数据类型的
 *     但是：Cat和Dog
 * 
 *     用法：
 *         引用变量 instanceof  类名
 *         p instanceof  Student -> false
 */
public class Test {
    public static void main(String[] args) {
        Person p = new Teacher();
        Person s = new Student();
        
        //s.study(); // 不可以  不能用子类的特有属性
        s.sleep();
        
        boolean b = p instanceof Student;
        System.out.println(b);
        
        //boolean b1 = p instanceof Animal; // 这样毫无意义p与animal根本没有任何关系
    }
}

 

package com.itstar.demo08;

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

package com.itstar.demo08;

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    
    public void catchMouse() {
        System.out.println("猫建瓯鞥");
    }


}

package com.itstar.demo08;

public class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    
    public void lookHome() {
        System.out.println("狗看家");
    }

    
}

package com.itstar.demo08;

public class Test {
    public static void main(String[] args) {
        // 两个子类，使用两次多态调用
        Animal a1 = new Cat();
        Animal a2 = new Dog();
        
        // a1与 a2 调用的是子类和父类共有的方法，运行走的子类重写的方法
        a1.eat();
        a2.eat();
        
        // 类型的向下转型Animal->Cat
        Cat c = (Cat)a1;
        c.catchMouse();
        
        // 可以编译成功 但是运行失败
//        Cat d = (Cat) a2;
//        d.catchMouse();
        
        // 为了防止异常的放生：a1属于Cat对象 a2属于Dog对象 强转
        // instanceof 判断
        if(a1 instanceof Cat) {
            Cat c1 = (Cat)a1;
            c1.catchMouse();
        }
        if(a2 instanceof Dog) {
            Dog d = (Dog)a2;
            d.lookHome();
        }
        
        
    }
}