黑马程序员 Java的面向对象特性

------- android培训、java培训、期待与您交流！ ----------

什么时候使用继承？
当事物之间存在着所属关系时，就可以使用继承，
所属：xxx是yyy的一种，即x继承y
如果A真继承了B，B中的锁有的功能是不是A都具备了。

继承子父类中的成员变化。 
1、成员变量：
a) 当子父类中出现同名的成员变量时，可以使用super关键字来区分，父类的成员变量。
b) Super和this用法很相似，this代表的是本类的对象，super代表父类的所属的空间，
c) 先有父类在有子类。面试中会出现，开发中几乎没有，因为父类的成员都是从下到上抽取的，子类中还保留相同的变量干嘛？
2、成员函数
   当子父类出现一模一样(返回值、函数名、参数列表全部相同)的函数时，就会出现调用时运行子类的方法的情况。
   这种情况，形象成为覆盖或者重写或者覆写。
   什么时候用覆盖？
   当对一个类中的功能的内容进行重新定义时，可以定义该类的子类，并保留父类中的功能声明，重新定义功能内容，并建立子类对象调用该功能。
   
    
/*
当子父类中出现一模一样的函数时，就会出现调用时运行子类的方法的情况。
这种情况，形象的称为 覆盖或者重写或者叫做覆写 override。

什么时候用覆盖?
当对一个类中的功能的内容进行重新定义的时，可以定义该类的子类，并保留父类中的功能声明，
重新定义功能内容。并建立子类对象调用该功能。

覆盖小细节：

1，子类方法覆盖父类方法时，权限必须大于等于父类的权限。

2，静态只能覆盖静态，或者被静态覆盖。

 

*/
class Fu
{
 public static void show()
 {
  System.out.println("fu show");
 }
}
class Zi extends Fu
{
 public static  void show()
 {
  System.out.println("zi show");
 }
}

class ExtendsDemo3 
{
 public static void main(String[] args) 
 {
//  Zi z = new Zi();
//  z.show();
  //Phone p = new Phone();
  NewPhone p  = new NewPhone();
  p.show();
 }
}

3、抽象类：
特点：
1、没有方法体的方法，称为抽象方法，必须存放在抽象方法类中，抽象方法和抽象类必须用abstract关键字来修饰，
2、抽象类不可以被实例化，为什么？因为调用抽象方法没有意义？为什么？因为它连方法体都不存在？
3、抽象类必须由其子类将抽象类中的抽象方法都覆盖后，其子类才可以被实例化，否则该子类还是抽象类。
Eg:
Abstract class Demo
{
 Abstract void show();
}
Class  SubDemo extends Demo

 Void show(){}
 //此时把父类中抽象方法覆盖，此时才能被实例化。
}
比如水果，它就是抽象的，不具体它包含各种各样的水果，每种水果有它自己的体现。

抽象类涉及的问题？
1、抽象类中是否可以定义非抽象的方法？
可以 首先抽象类是一个类，类是用来描述事物，只不过描述事物过程中有些信息不具体，抽象类和一般类异同点：
相同：抽象类和一般类都用于描述事物，都可以定义成员。
不同：抽象类中可以定义抽象成员函数，（抽象要么修饰类要么修饰函数）而一般类不可以。
      抽象类不可以实例化，一般类可以实例化。
2、抽象类中是否有构造函数？
   有，而且抽象类虽然自身不可以被实例化，但是其子类覆盖了所有的抽象方法后，是可以实例化的。所以抽象类的构造函数是用于给其子类对象进行实例化。
3、抽象类通常都是一个父类？
是、因为需要子类去覆盖父类中的抽象方法。
代码体现：
Abstract class Demo{
 Abstract voif show1();
 Abstract void show2();
 }
Abstract class SubDemo extends Demo
{
 Void show1();
}
Class Test extends SubDmeo
{
 Void show2();
}

4、抽象类中可不可以不定义抽象方法？
 可以；看上去没有什么意义，其实有点意义，就是不让这个类创建对象，为什么不让创建？
代码体现：
 interface InterTest//这是一个测试接口，有4种测试方式。
      {
 void test1();
 void test2();
 void test3();
 void test4();
      }
 abstract class InterTestImpl implements InterTest//用这个类进行所有的空实现。但是创建对象是毫无意义的。所以用抽象。
 {
     public void test1(){}
     public void test2(){}
     public void test3(){}
     public void test4(){}
 }
      class Test2 extends InterTestImpl
      {
 public void test2(){}
      }
      class Test3 extends InterTestImpl
      {
 public void test3(){}
      }
      /*
      class InterTestImpl implements InterTest
      {
  public void test2()//
  {
  sop("testimpl test2");
  }
  public void test1(){}//这样做实现太麻烦。代码重复。如何改进？
  public void test3(){}
  public void test4(){}
      }
      */

5、抽象关键字 不可以和那些关键字共存？
 Final：修饰了类是一个最终类，不可以被继承，然后abstract修饰的类必须是父类，需要被继承、冲突、非法的修饰符组合，abstract 和final
 Static:抽象方法被static修饰，就具备了可以被类名直接调用的的特点，但是抽象方法被调用没有意思。
 Priavte：因为抽象方法被私有，无法被覆盖。
 
代码体现： 雇员实例：
   需求：公司中程序员有姓名、工号、薪水、工作内容。
 项目经理除了姓名、工号、薪水、还有奖金、工作内容
 进行数据建模
 做问题领域的分析就是找出问题领域的对象。

分析:
在这个问题领域中有两个对象：
程序员：
 属性：姓名，工号，薪水
 行为：工作内容
项目经理：
 属性：姓名、工号、薪水、奖金
 行为：工作内容。

 这时候不能用项目经理去继承程序员。因为职能不同，但是有共性，只能抽取。
 就有了员工：
 属性：姓名，工号，薪水
 行为：工作内容

*/
abstract class Employee
{
 private String name;
 private String id;
 private double pay;
 Employee(String name,String id,double pay)
 {
  this.name=name;
  this.id=id;
  this.pay=pay;
 }
 public abstract void work();//工作内容是无法知道的。
}
class Programmer extends Employee
{
 Programmer(String name,String id,double pay)
 {
  super(name,id,pay);
 }
 public void work()
 {
  System.out.println("code");
 }
 
}

class Manager extends Employee
{
 private double bonus;
 Manager(String name,String id,double pay)
 {
  super(name,id,pay);
  this.bonus=bonus;
 }
 public void work()
 {
  System.out.println("manage");
 }
}
4、接口：
格式：interface{}
表现特点：
1、里面的方法都是抽象的。
2、接口中的成员都有固定的修饰符，最常见的成员：全局常量抽象方法。只是最常见，不代表只有它们没有其他的，
       全局常量，共有的不需要对象，直接用接口调用的，不可变的。
 表现形式：Public static final
    抽象方法：public abstract
3、接口的成员都是public的。
4、接口是不可以创建对象的。就相当于是抽象的特殊表达形式。（但是有区别和抽象类）
5、类与类之间是继承关系，类与接口之间是实现关系。
6、接口的出现可以多实现，避免了单继承的局限性。
7、一个类在继承一个类的同时，还可以实现多个接口、
8、接口与接口之间是继承关系，而且可以多继承，以为接口的方法都没有主体。
思想特点：
1、对外暴露的规则。
      外设要介入计算机中，因为计算机外面提供了接口，这就是规则。
2、程序的功能扩展
3、降低了耦合性
4、用来多实现
结合电脑主板的思想进行阐述，它是个规则，。对外提供的规则
它提高了我们功能的扩展性，降低了耦合性。
主板和声卡：主板使用规则，声卡实现规则。

与抽象类的区别：抽象类有单继承的局限性，接口没有

5、java对多继承记住改良，以多现实接口的方式来体现。
差别：多继承因为父类中有相功能时，会造成不确定性。
为什么可以实现多实现？
因为继承中父类的方法有方法体？这才是造成不确定性的根本原因，而此处是没有方法体的。
 代码体现：  
 interface A
 {
  //int show();//这样是不可以的。无法覆盖。
  void show();
 }
 interface B
 {

 // void method();
  void show();//当有重复的方法时。但是此时子类复写它是可以的，为什么？
   //因为继承中父类的方法有方法体。这才是造成不确定性的根本原因。而
  //此处是没有方法体的。
 }
 class C extends D implements A,B//多实现。此时c必须覆盖两个方法
 {
  public void show(){}
  //public void method(){}

 }
 //一个类在继承一个的类的时候还可实现多实现
 class D 
 {
  public void function();
 }
 //接口之间是可以继承，而且支持多继承。
 interface InterA
 {
  void showA();
 }
 interface InterB
 {
  void showB();
 }
 interface InterC extends InterA,InterB//为什么此处可以实现多继承，因为方法没有主体。
 {
  void showC();
 }

 class InterfaceDemo2 
 {
  public static void main(String[] args) 
  {
   C c=new C();
   c.show();
   System.out.println("Hello World!");
  } 
 }
6、抽象类和接口之间的区别：
      共性：它们都是不断抽取出来的抽象非概念
      区别：1、抽象类只能被单继承、接口可以被多实现，避免了单继承的局限性。
 2、抽象类中可以定义抽象方法，和非抽象方法，它可以用于定义体系的基本共性的内容。接口中只能定义抽象方法，它主要用于对象的功能的扩展。
 3、抽象类是继承关系，是is a关系，接口是实现关系是like a关系。
 4、抽象类中的成员修饰符都是自定义的，接口中的修饰符都是固定的。
记住：不要把接口狭义的理解为interface,应该理解广义些，就是对外提供的规则，凡是对外暴露的都可以是接口。

7、多态：重点掌握
     定义：某一类事物的多种存在形态。
代码实现：
 class 动物
   {}
   class 猫 extends 动物
   {
 
   }
   猫 x=new 猫();
   动物 y=new 猫();//父类的引用变量指向了其子类的对象。

   多态在代码中的体现，父类或者接口的引用指向了自己的子类对象。
   实现代码：
   class Animal
   {
 abstract void eat();
   }
   class Dog extends Animal
   {
 void eat()
 {
  sop("啃骨头");
 }
 void lookHome()
 {
  sop("看家");
 }
   }
   class Cat extends Animal
   {
 void eat()
 {
  sop("吃鱼");
 }
 void catchMouse()
 {
  sop("抓老鼠");
 }
   }
   class Pig extends Animal
   {
 void eat()
 {
  sop("猪饲料");
 }
 void gongdi()
 {
  sop("拱地");
 }
   }
class DuoTaiDemo
{
 public static void main(String[] args)
 {
  //Cat c=new Cat();
  //c.eat();
  //Cat c1=new Cat();
  //c1.eat();
  //method(c);
  //method(c1);
  重要知识点：----开发都用！
  Animal a=new Cat();//此处猫对象类型自动向上提升---向上转型，当指向使用体系基本功能时，可以向上转型操作。
  为什么体现多态性？
  首先猫是一个实体，是一个猫类型，因为有了继承，是动物中的一种，把这个实体称之为动物也可以，所以它具备了两种形态，猫和动物。这便是体现了多态性。
  //一旦向上转型，猫就不是猫了，已经是动物类型了。
  a.catchMouse();//编译失败。

  但是现在想执行猫的抓老鼠的功能怎么办？
  向下转型：
  Cat c=(Cat)a;//向下转型。当使用子类对象中的特有内容时，才做向下转型。
  c.eat();
  c.catchMouse();//此时是可以实现猫的抓老鼠的功能的。
  总结：在多态转型中，至始至终只有子类对象做着类型的变化。

  method(new Cat());

  
 }
 public static void method(Animal a)//Animal a=new Cat();
 {
  
  
  重点知识点：instanceof
  if(a instanceof Cat)//对象instanceof 类型 判断具体对象是否是指定的类型。
  {
   Cat c=(Cat)a;//编译通过，但是不能运行，此时类型转换异常classCastException;
  //此时为了程序的严谨性，需要对传入的的对象进行判断。
   c.catchMouse();
  }
  else if(a instanceof Dog)
  {
   Dog d=(Dog)a;
   d.lookHome();
  }
  a.eat();
  总结：
  instanceof是一个关键字，用于判断对象的类型。什么时候用？
  当进行向下转型时，先判断该对象是否符合被转成的子类型。
 }
}
8、重点理解：
1、多态的好处：提高了代码的扩展性，有了多态，前期设计好的内容可以使用后期出现的子类内容，对于指挥对象做事情这件事情，如果对象很多，指挥起来很麻烦，抽取对象的共性类型，对该类型的事物进行指挥就会变的很简单。
2、多态的前提：1、必须要有关系：继承、实现。
      2、必须有覆盖的操作。

3、多态的弊端：前期的程序虽然可以使用后期出现的子类内容，但是只能使用子类覆盖父类中的内容，不能使用子类中的特有内容。