Java结合源码之究极基础复习&设计模式复习

多态：父类引用指向子类对象

多态的实现让比如不同职业的人可以在一个窗口买票，不用每个职业都特别分一个窗口。

阶段一:
不用多态的话，有个车的话，你得写个车的实体类，然后里面写车被开的方法。
有个人的话，你得写个人开车A的方法，把车的对象传进去。有了车B还要加开车B的方法。
当有新车的时候，要增加新车的类，然后在主函数中new出新的车

这样会被砍死的。

阶段二
将车抽象为抽象类，具体的车型继承此抽象类。人的构造函数的参数，写车抽象出来的类.。以后要开哪个车，就在set函数里设置抽象类。

最大的好处感觉就是person这个类基本不需要修改了。 set抽象类就表达出以后能开所有车。

---

这里的set（Car car）是用在方法的参数中，还可以用在方法的返回类型中
如下：

/**
*   我们将多态使用在方法的返回类型中
*   Car可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口
*/
public class CarFactory{
public Car factory(String carName){
   if(carName.equals("JD")){
      return new JD();
   }else if(carName.equals("Benz")){
      return new Benz();
   }else{
      System.out.println("对比起,不伺候");
      return null;
   }
}
}

另外,我们在JDK中可以大量的看到多态的应用,比如在Object类中的equals(Object obj)方法中,参数是个Object
类型的参数.因为Object是Java中所有类的基类.,但是才传入参数的时候,可以传入任何一个类的对象
这就是多态的应用!

总结：

多态存在的三个必要条件
继承
重写
父类引用指向子类对象

封装：
采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。（this是指向自己类的引用，super访问父类成员变量的引用）

继承：如果没有继承，每个动物的实体类都要，重复地写吃喝睡三个方法。有继承的话在父类类写完，子类构造方法super(name,id)就好了。(提高耦合性)
extends可以有多个儿子，不能有多个父亲
implements使类和类间可以多继承，类似多个父亲

子类的每个构造器都必须自动调用父类构造器，除非已经super了。否则自动调用父类无参构造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClas2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}
输出结果：
------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

---

泛型：没有泛型的话，push进集合统统变为object类型。取出来是要强制转化。提高集合类的可读性和安全性（避免转换异常）和效率（不用装箱拆箱）。在编译时会进行泛型擦除。

而怎样动态的获取类型，又提到了反射。

反射：加载的时候，JVM将xxx.class读入内存，并为之创建一个Class对象

装箱拆箱：

public static void main(String[] args) {
    Integer i = 100;
    Integer j = 100;
    Integer m = 200;
    Integer n = 200;
    System.out.println(i==j);
    System.out.println(m==n);
}
结果分别是true和false

源码一定要自己看，看别人博客里的是记不住的。。。

先来看双精度的double，占8字节，有效数字 15-16位
public static void main(String[] args) {
    Double i = 100.0;
    Double j = 100.0;
    Double m = 200.0;
    Double n = 200.0;
    System.out.println(i==j);
    System.out.println(m==n);
}
结果居然是两个false

再来看单精度的float，占4字节，有效数字 6-7位
public static void main(String[] args) {
    Float i =  100.0f;
    Float j = 100.0f;

    System.out.println(i==j);
}
结果为false

来一道题：
java中float f = 3.4;是否正确？
　　 不正确，3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于向下转型会造　　成精度损失，因此需要强制类型转换float f = (float)3.4;或者写成 float f = 3.4f;才可以。

再多提一句，sting的“==”比较的是地址。equals比较的是内容

final修饰类则类不能被继承，修饰方法则方法不能被重写，修饰变量则变量不能被修改

---

抽象类与接口的应用

抽象类可以看作正常java bean多一个抽象方法，是一种模板。而接口是一种规范，只能有抽象方法和final常量。
优先用接口，因为可以避免单继承。尽量不要直接继承其他类。除非是抽象类。
抽象类应用场景有模板模式，接口有工厂模式和装饰模式。

abstract class Person{
private String name;
private int age;
// get set

public abstract String talk();//只定义不实现
}

class student extends Person(){
private int salary;
public Student(String name,int age,int salary){
super(name,age);
this.salary=salary;
}
public String  talk(){
//return "";
}
}

以上是抽象类，是不同的类中把相同的部分留下来，把需要单独实现的方法提取出来。

interface Machine{
public void  start();
public  void stop();
}

class Phone implements Machine{
System.out.println();
}

//重点来了！
 class Person{
	public static void use((Machine machine)) {
	machine.start();
	machine.stop();
	}
} 

public static void main(String[]args){
Person.use(new Phone());
}

接口里抽象方法太多的时候，不如就用抽象类先实现接口，
然后用真正的类继承抽象类，重写想要的方法就好了。

抽象类中可以包含若干接口，接口中也可以包含若干抽象类。

---

工厂模式

interface Fruit{
void eat();
}
class apple implements Fruit{
void eat(){
}
}
class Factory{//定义工厂类
Fruit f=null;
public static Fruit getFruit(String className){
if("apple".equals(className)){
f=new Apple();
}
return f;
}
public static void main(String[]args){
Fruit f=Factory.getFruit("apple");//实例化接口
f.eat();
}
}