Data类 抽象类 和接口

 

Date 类 的用法

    //建立一个new类对象
        Date date  = new Date();
        Date date1 = new Date(System.currentTimeMillis()+100);
        System.out.println(date1);
//为时间加100毫秒
        System.out.println(date1.compareTo(date1));
      System.out.println(date1.before(date1));
2.Date的格式设置 
  // 获得当前的系统日期和时间
        Date date = new Date();
        // 创建DateFormat对象
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        // format(Date date)：按照指定模式，把日期转为字符串
        String s = dateFormat.format(date);
        System.oudf.println("SimpleDateFormat:" + s);

二：抽象类

 

抽象方法和抽象类必须用abstract修饰符来定义，有抽象方法的类只能是被定义的抽象
类，抽象类里面可以没有抽象方法

 抽象类的使用规则
1.抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修
饰
2.抽象类不能被实例化，即不能使用new 关键字来调用抽象类的构造器创建类的实例

3.抽象类可以包含成员变量 方法 主要用于被子类调用

4.抽象类 可以被多个类继承 重写里面的方法 
例如  建立一个Shape 抽象抽象类和 Triangle和Circle类 来继承
 

package Test;


/**
 * @author Administrator
 */
public abstract class Shape {
    //创建抽象类里面的一个对象
   private String color;
    //定义一个计算周长的方法
    public abstract double calPerimeter();
    //定义一个返回形状的抽象方法
    public abstract String getType();

    public Shape(String color) {
        System.out.println("执行Shape构造器1");
        this.color = color;
    }

    public Shape() {
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

package Test;
/**
 * @author Administrator
 */
public class Triangle extends Shape {
    private double a, b, c;

    public Triangle() {
    }

    public Triangle(String color,double a, double b, double c) {
       super(color);
          this.setSides(a,b,c);

    }

    public void setSides(double a, double b, double c) {
        if (a >= b + c || c >= b + a || b >= a + c) {
            System.out.println("三角形两边和大于第三边");
            return;
        }
        this.a= a;
        this.b=b;
        this.c=c;
    }

    @Override
    public double calPerimeter() {
        return a+b+c;
    }

    @Override
    public String getType() {
        return "三角形";
    }
}

 

package Test;

/**
 * @author Administrator
 */
public class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    public void setRadius(double radius){
        this.radius = radius;
    }

    @Override
    public double calPerimeter() {
        return 2*Math.PI*radius;
    }

    @Override
    public String getType() {
        return getColor()+"圆形";
    }

    public static void main(String[] args) {
        Shape s1 =new Triangle("黑色",3,4,5);
        Shape s2 = new Circle("黄色",3);
        System.out.println(s1.getType());
        System.out.println(s1.calPerimeter());
        System.out.println(s2.getType());
        System.out.println(s2.calPerimeter());
    }
}

上面的例子 很好的利用了 抽象类的优势 发挥了Java多态的性质，使程序更加的灵活
使用abstract修饰类 注定该类只能被继承 final修饰的类是不能被继承的 final修饰
的类里面的方法也不能被重写 所以 final和abstract 两个永远不可能在一起（为了
好记忆 委婉的拒绝表达式  我们虽然同为修饰符 你的属性是abstract 而我的属性是
final  你懂得 哈哈哈）

抽象父类可以只定义需要的某些方法，把不能实现的部分抽象方法 留给子类实现。
抽象父类只定义了一个通用的算法 完善的方法由子类来完成 就好比如 人为父类 男人
女人为两个子类 所以两个子类除了通用 外，在各自的类里面完善自身。

 

三：接口

 

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更加彻底，则可以提炼出
一种更加特殊的抽象类--接口 。Java9对抽象类进行了该进，允许在接口中定义默认的
方法和类方法。
2.接口体现的是规范和实现分离的设计哲学，接口中定义了一批类要遵守的规范，并不
关心这些类的内部实现。例如 安卓数据线 只要手机符合接口规范，不管什么品牌的手
机都可以使用。因此，接口定义的是多个类共同的公共行为规范，这些行为是与外部交
流的通道，这就意味着里通常是定义一组公用方法。

 

3.定义一个接口

 

package Test;

/**
 * @author Administrator
 */
public interface Output {
    //接口中定义的成员变量只能是常量
    int MAX_CACHE_LINE = 50;

    //接口定义的普通方法只能是pubic的抽象方法
    void out();

    void getDate(String msg);

    //在接口中定义默认的方法，需要使用default修饰
    default void print(String... msgs) {
        for (String msg : msgs) {
            System.out.println(msg);
        }
    }

    default void test() {
        System.out.println("默认的test（）方法");
    }

    static String staticTest() {
        return "接口里类的方法";
    }

    //定义私有方法
    private void foo() {
        System.out.println("foo的私有方法");
    }

    //定义私有静态方法
    private static void bar() {
        System.out.println("bar静态私有方法");
    }
}

Java8 允许在接口中定义默认的方法，默认的方法必须使用default（默认方法就是实
例方法 有方法体的实例方法）
从某个角度来说接口可以被当成一个特殊的接口，因此一个Java源文件中最多只能有一
个public接口，如果一个Java源文件中定义了一个public接口，则源文件的主文件名
必须与该接口名相同。

 

4.接口的继承

接口的继承和类的继承不一样，接口完全支持多继承，即一个接口可以有多个直接父类
，一个接口继承多个父接口 ，多个父类排在extends 关键字之后 父类之间用，好隔开

package Test;

/**
 * @author Administrator
 */
interface InterfaceA {
    int PROP_A = 5;

    void testA();
}

interface InterfaceB {
    int PROP_B = 6;

    void testB();
}

interface InterfaceC extends InterfaceA, InterfaceB {
    int PROP_c = 7;

    void testC();
}

public class InterfaceExtendsTest {
    public static void main(String[] args) {
        System.out.println(InterfaceC.PROP_A);
        System.out.println(InterfaceC.PROP_B);
        System.out.println(InterfaceC.PROP_c);
    }

}

5.实现接口的类

package Test;

/**
 * @author Administrator
 */
//定义一个Product接口
interface  Product{
    int getProduceTime();
}
//让Printer类实现Output类和product接口
public class Printer implements Output,Product {
  private String[] printData = new String[MAX_CACHE_LINE];
  //用以记录当前的需打印的作业数
    private  int dataNum = 0;

    @Override
    public void out() {
  //只要还有作业就继续打印
        while (dataNum>0){
            System.out.println("打印机打印"+printData[0]);
            //把作业队列整体前移一位，并将剩下的作业减1
            System.arraycopy(printData,1,printData,0,--dataNum);
        }
    }

    @Override
    public void getDate(String msg) {
        if (dataNum>=MAX_CACHE_LINE) {
            System.out.println("输出队列已满，添加失败");
        }else {
            //把打印数据添加到队列里，以保存数据加一
            printData[dataNum++] = msg;
        }
    }

    @Override
    public int getProduceTime() {
        return 45;
    }

    public static void main(String[] args) {
        //创建一个printer对象当成output使用
        Output o = new Printer();
        o.getDate("Java");
        o.getDate("Java讲义");
        o.out();
        o.getDate("Java123");
        o.getDate("Java456");
        o.out();
        o.print("孙悟空","猪八戒","白骨精");
        o.test();
        //创建一个printer对象 当成product使用
        Product p = new Printer();
        System.out.println(p.getProduceTime());
        //所有接口类型的引用变量都可以直接赋值给Object类型的变量
        Object object9oi = p;
    }
}

接口不能显示继承类，但所有的接口类型的引用变量都可以赋给Object类型的引用变量。