java基础--03（复用类）

1.继承

   继承的时候需要注意访问控制符，默认的访问控制符是包访问权限，继承其他包的类，只嗯呢该访问其public的成员，所以为了继承一般的规则是将数据的成员设为private,方法设为public。当创建一个导出类的对象时，该对象包含了一个基类的子对象，这个子对象与你用基类直接创建一个对象是一样的，对基类的初始化只有一种方法，就是在构造器中调用基类的构造器来执行初始化，基类构造器具有执行基类初始化的所有知识和能力，java会自动在导出类的构造器中插入对基类构造器的调用。

默认的话调用基类的默认构造器，即无参构造器，但是如果没有默认的基类构造器或者想调用一个有参的构造器，则需要使用关键字super,并且传入参数，放在子类构造器的第一行。

如果java的基类中有一个方法重载了很多次，在导出类中重新定义该方法的名称并不会屏蔽在基类中的任何版本。

在组合和继承中，都允许在新的类中放置子对象，只不过组合是显示的这样做，而继承是隐式的这样做。

在继承中可以这样看待新类和现有类的关系，新类是现有类的一种类型。所以新类可以向上转型为现有类。

组合和继承该如何选择？组合：新类嵌入现有类的private对象，新类用户看到的只是为新类定义的接口，而不是嵌入对象的接口。到底用组合还是继承，一个判断方法是是否需要从新类向基类向上转型，如果必须向上转型，则继承是必要的。

 

1.抽象类: abstract

       由于抽象类创建对象是不安全的，所以抽象类不可实例化，如果从一个抽象类继承，并想创建该新类的对象，那么就必须为基类中的所有抽象方法提供方法定义，如果不这样做，那么导出类也是抽象类，并且要加上abstract这个关键字。

抽象类有这样的一种用途，我们想阻止产生这个类的任何对象。

抽象类是很有用的重构工具，因为他们使得我们可以很容易的将公共方法沿着继承层次结构向上移动。

　　抽象：不具体，看不明白。抽象类表象体现。

　　在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。

　　抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

 

     抽象类的特点：

    1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

    2：抽象方法只定义方法声明，并不定义方法实现。

    3：抽象类不可以被创建对象(实例化)。

    4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

 

　　抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

2：抽象类中是否可以定义非抽象方法？

　　　　　　可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final , private , static 

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

2.接 口：★★★★★

  接口可以包含一些域，但是这些域隐式的是static 和final的。所以接口就很便捷的成为了一种用来创建常量组的工具，这些域不是接口的一部分，他们被存在了该接口的静态存储区域内。

  创建一个能够根据所传递的参数对象不同而具有不同行为的方法，被称为策略模式。

public class Processor {
    public String name(){
        return getClass().getSimpleName();
    }
    Object process(Object o){
        return o;
    }
}

public class Upcase extends Processor {
    String process(Object input) {
        return ((String) input).toUpperCase();
    }
}

public class Downcase extends Processor {
    String process(Object input) {
        return ((String) input).toLowerCase();
    }
}

public class Splitter extends Processor {
    String process(Object input) {
        return Arrays.toString(((String) input).split(" "));
    }
}

  

public class Apply {
    public static void process(Processor p, Object o) {
        System.out.println("Using Process " + p.name());
        System.out.println(p.process(o));
    }

    public static void main(String[] args) {
        process(new Upcase(), "To change this template use File");
        process(new Downcase(), "To change this template use File");
        process(new Splitter(), "To change this template use File");
    }
}

  

 但是这样耦合过紧，Apply.process()方法无法复用，如果Processor是一个接口，就可以完全解耦了。

 Processor变成接口：

public interface Processor {
    String name();

    Object process(Object o);
}

再来两个抽象类，分别处理String类型和Integer类型，抽象类将公共的方法提取出来了

public abstract class StringProcessor implements Processor {
    @Override
    public String name() {
        return getClass().getSimpleName();
    }

    public abstract Object process(Object o);
}

public abstract class IntegerProcess implements Processor {
    @Override
    public String name() {
        return getClass().getSimpleName();
    }

    public abstract Object process(Object o);
}

 实现类：
 

public class Upcase extends StringProcessor {
    public String process(Object input) {
        return ((String) input).toUpperCase();
    }
}

public class Splitter extends StringProcessor {
    public String process(Object input) {
        return Arrays.toString(((String) input).split(" "));
    }
}

public class Downcase extends StringProcessor {
    public String process(Object input) {
        return ((String) input).toLowerCase();
    }
}

public class AutoNumber extends IntegerProcess {
    @Override
    public Integer process(Object o) {
        return (Integer) o + 5;
    }
}

  测试：

public class Apply {
    public static void process(Processor p, Object o) {
        System.out.println("Using Process " + p.name());
        System.out.println(p.process(o));
    }

    public static void main(String[] args) {
        process(new Upcase(), "To change this template use File");
        process(new Downcase(), "To change this template use File");
        process(new Splitter(), "To change this template use File");
        process(new AutoNumber(), 5);
    }
}

 

上面就完美了吗？没有。组合拳还没有结束，因为我们经常碰到的情况是无法修改你想要的使用类，例如下面的这个关于Long类型的处理，他没有接口：

public class LongProcess {
    public String name() {
        return getClass().getSimpleName();
    }

    public Long process(Long value) {
        return value;
    }
}

public class LongAdd extends LongProcess {
    public Long process(Long value) {
        return value + 5L;
    }
}

  在这种情况下，可以使用适配器模式，适配器中的代码将接受你所拥有的接口，并产生你所需要的接口。这里面还用到了代理。

如果不用代理，可以用继承：

public class LongAdapter extends LongAdd implements Processor {
//    private LongProcess longProcess;
//
//    public LongAdapter(LongProcess longProcess) {
//        this.longProcess = longProcess;
//    }

    @Override
    public String name() {
        return super.name();
    }

    @Override
    public Object process(Object o) {
        return super.process((Long) o);
    }
}

 结果还是一样的：

  

  接口是实现多重继承的途径，而生成某个接口的对象的典型方式就是工厂方法设计模式，这与直接调用构造器不同，我们在工厂对象上调用的是创建方法，而该工厂对象将生成接口的某个实现对象。

1：是用关键字interface定义的。

2：接口中包含的成员，最常见的有全局常量、抽象方法。

　　　　注意：接口中的成员都有固定的修饰符。

　　　　成员变量：public static final 

　　　　成员方法：public abstract 

interface Inter{

public static final int x = 3;

public abstract void show();

}

3：接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

4：类与类之间存在着继承关系，类与接口中间存在的是实现关系。

继承用extends  ；实现用implements ；

5：接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。 

6：一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。

7：其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。

 

接口都用于设计上，设计上的特点：（可以理解主板上提供的接口）

1：接口是对外提供的规则。

2：接口是功能的扩展。

3：接口的出现降低了耦合性。

 

抽象类与接口：

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

 

抽象类和接口的共性：都是不断向上抽取的结果。

 

抽象类和接口的区别：

1：抽象类只能被继承，而且只能单继承。

　　　　　　接口需要被实现，而且可以多实现。 

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

　　　　　　接口中都有抽象方法，需要子类去实现。

3：抽象类使用的是  is a 关系。

　　　　　　接口使用的 like a 关系。 

4：抽象类的成员修饰符可以自定义。

　　　　　　接口中的成员修饰符是固定的。全都是public的。

 

　　在开发之前，先定义规则，A和B分别开发，A负责实现这个规则，B负责使用这个规则。至于A是如何对规则具体实现的，B是不需要知道的。这样这个接口的出现就降低了A和B直接耦合性。 

 

1.Final关键字

    不改变的理由是设计或者效率，final在编译时执行运算，减轻了运行时的负担，但是并不说使用了final在编译期就可以知道它的值，  final数据，final用于常量之上，必须是基本的数据类型，并且必须赋初值。这个数值恒定不变的理解是怎么样的呢？是指在比如这个类初始化的时候，给这个常量赋上一个随机值，那么再次初始化这个类的时候这个常量的值还是上次随机得到的那个值，这个怎么去和static修饰的比较注意

  定义常量的一个经典的方式：

public static final int VALUE_ONE = 23;

 public表明这个常量可以用于包之外，static表明他只有一份，final表明他是一个常量。    

    一个既是static又是final修饰的域只占据一段不能改变的地址空间。他在装载的时候已经被初始化，再次创建对象不会再次被初始化。

      对于引用对象final使引用恒定不变，不能认为他是final就无法改变它的值，他只是无法将这个引用再次指向一个新的对象而已。同样适用于数组。就是说在初始化的时候他已经指向一个引用，再new一个对象让他去指向是不行的。

public class Value {
    int i;

    Value(int i) {
        this.i = i;
    }
}

    

空白final怎么理解？在定义的时候没有赋初始值，但是必须在每个构造器中给他赋初值。

   这个也是final域在使用前总是被初始化的原因所在。

Final参数怎么理解，无法在方法中更改参数所指向的对象。

Final方法：最重要的一个目的就是防止任何类修改他的定义，即防止被覆盖。

方法的覆盖什么时候会出现？只有某方法是基类方法的接口的一部分时才会出现，检验的方法就是将一个对象向上转型为他的基本类型，再调用相同的方法，能调不报错，那么子类的方法就是覆盖的，如果调父类的方法出错就不是覆盖的。比如private修饰的就会报错。

类中所有的private方法都隐式的指向为final

Final类：永远不打算继承该类，不希望他被改变

  Final类中的域可以根据个人的意愿选择为是或者不是final,不论类是否被定义为final,相同的规则都适用于定义的final域，然而final类的方法默认都是隐式指向为final的。

题目：

1.抽象类实现一个接口需要实现接口的所有方法吗？

    

   

 2.处理日期的类在java的哪个包中？

 3.Hibernate：关于一对多双向关联中的<set>元素的inverse属性