1.covariant Return typs(协变返回类型)

  首先应该清楚返回类型的种类:void(无返回)、基础数据类型(如:int包括String)、引用类型。

  而协变返回类型主要针对的是引用类型，而它的前提条件是实现了接口或抽象类方法，利用的是java的多态特点。

  如下代码:

public interface Person{

   Object getObj();
}

public class Man implements Person{
   
   @Override
   public Man getObj(){  
      return new Man();
   }

}

   在实现类中，返回一个明确的类型，在使用中可以不做类型转换或安全转换。假设，如果返回的是Object，又会是一个什么情况呢？


2.Interseactional Generic Types(交叉泛型)

   如List<T> 很多通用java类都使用了泛型。而交叉泛型，这个就有点意思了。

代码如下：

public interface Writer {
    void write(); 
}

public class WriterComposite<T extends Writer> implements Writer {

    private final List<T> writers;

    public WriterComposite(List<T> writers) {
        this.writers = writer;
    }

    @Override
    public void write() {
        for (Writer writer: this.writers) {
            writer.write(); 
        }
    }
}
public interface Reader {
   void read(); 
}

public interface ReaderWriter implements Reader, Writer {}

public class ReaderWriterComposite<T extends ReaderWriter> implements ReaderWriter {

    private final List<T> readerWriters;

    public WriterComposite(List<T> readerWriters) {
        this.readerWriters = readerWriters;
    }

    @Override
    public void write() {
        for (Writer writer: this.readerWriters) {
            writer.write(); 
        }
    }

    @Override
    public void read() {
        for (Reader reader: this.readerWriters) {
            reader.read(); 
        }
    }
}
public class ReaderWriterComposite<T extends Reader & Writer> implements Reader, Writer {

    private final List<T> readerWriters;

    public WriterComposite(List<T> readerWriters) {
        this.readerWriters = readerWriters;
    }

    @Override
    public void write() {
        for (Writer writer: this.readerWriters) {
            writer.write(); 
        }
    }

    @Override
    public void read() {
        for (Reader reader: this.readerWriters) {
            reader.read(); 
        }
    }
}


  其中 T extends Reader & Writer 片段就是交叉泛型的体现。

  同时通过上面几个类，可以发现各接口（实现类）既可独立使用，也可以复合使用，充分体现了各个的独立性与自我职责性，低耦合度。而这充分的利用了接口的便利性。

  抽象类也可以这样使用，但是抽象类只能通过extends的形式而且也只能是一个。


3.Auto-Closeable Classes(自动关闭类)

   java中很多时间都会抛出异常，然而针对一些资源文件的处理，如：文件流、数据库处理等。如果出现异常，通常情况下都是需要关闭资源的，否则就会造成资源泄露，进而应用崩溃。

   一般我们都会使用try{}catch(Exception e){}finnally{} 块来最后关闭资源的方式来处理这种情况。

还有一种方式是try-with-resource,即try(resource){}catch(Exception e){},在执行完try块并在抛出异常之前，自动关闭资源。

  使用这种方式需要有实现AutoCloseable或Closeable接口，并实现close()方法。而这个close方法就是我们自己关闭资源或处理其他的关键。

代码如下：

public class Resource implements AutoCloseable {

    public Resource() throws Exception {
        System.out.println("Created resource");
    }

    public void someAction() throws Exception {
        System.out.println("Performed some action");
    }

    @Override
    public void close() {
        System.out.println("Closed resource");
    }
}
try (Resource resource = new Resource()) {
    resource.someAction();
} 
catch (Exception e) {
    System.out.println("Exception caught");
}


4.Final Classess and Methods(final 类和方法)

   相信final的使用大家都比较熟悉，在此不做过多解释。

   final 修饰变量时，变量不能被更改；

   final修饰方法时，方法不能被重写；

   final修饰类时，类不能被继承。