黑马程序员--继承 抽象 接口

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一继承概述： 

1、Java语言中，Java只支持单继承，不支持多继承。 即使一个类只能有一个子类(extends) 一个父类(super)，不允许多个，容易有安全隐患。 
(1)、比如，同时继承两个类，但是两个类中有连个同名函数。 
(2)、但是Java保留了这种机制，并用另一种体现形式来完成表示，叫做多实现。 
(3)、Java支持多层继承，也就是一个继承体系，B继承A，C继承B，这样C就既有了A的功能，又有了B的功能，这就是多继承。 

2继承的出现（Extends）： 
 1，提高了代码的复用性。 
 2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。 
注意： 
千万不要为了获取其他类的功能，简化代码而继承。 
必须是类与类之间有所属关系才可以继承，所属关系，父类、子类(is a)。 

二子父类中变量的特点： 

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。 
子类要访问父类中的同名变量，用super。 
super的使用和this的使用几乎一致，this代表的本类对象的引用，super代表的是父类对象的引用。 
class Fu
{
int num=4;
}
class Zi extends Fu
{
public void show()
{
System.out.println(num);
}
}
class Object1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}

三子父类中函数的特点： 

1当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）。 


2当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖，保留父类的功能定义，并重写功能内容。 

3覆盖：子类覆盖父类，必须保证子类权限大于等于父类，才可以覆盖，否则编译失败。静态只能覆盖静态。 


4记住：重载只看同名函数的参数列表；重写子父类方法要一模一样。 
class Tel
{
void show()
{
System.out.println("numble");
}
}
class NewTel extends Tel
{
void show()
{
super.show()
System.out.println("name");
System.out.println("pic");
}
}


四子父类中构造函数的特点: 

1）在对子类对象进行初始化时，父类的构造函数也会运行。 那是因为子类的构造函数默认第一行有一条隐式的语句super()； 
super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super()； 

2）子类一定要访问父类中的构造函数，因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时 ，要先访问一下父类中的构造函数，如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。 
class Fu
{
//Fu类构造函数
Fu()
{
System.out.println("Fu run");
}
}
class Zi extends Fu
{
//Zi类构造函数
Zi()
{
System.out.println("zi run");
}
}
class Object1
{
public static void main(String[] args)
{
Zi z=new Zi();



注意：super语句一定要定义在子类构造函数的第一行。 
继承弊端：打破了封装性。 
子类的实例化过程： 
结论： 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。 
因为子类每一个构造函数内的第一行都有一句隐式super（）； 当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。 当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。 

class Object1
{
public static void main(String[] args)
{
Student s=new Student("zhangsang",20);
s.study();
}
}
class Person
{
String name;
int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public void show()
{
System.out.println(this.name+"..."+this.age);
}
}
class Student extends Person
{
String name;
int age;
Student(String name,int age)
{
super(name,age);
}
public void study()
{
super.show();
}
}

五final——关键字最终值 
1、可以修饰类、函数、变量。 
2、被 final 修饰的类，不可以被继承，为了并避免被继承，被子类复写功能。 
3、被 final修饰的方法。 
4、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。 
final int X=3;
5、当在描述事物时，一些数据的出现 值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读， 
而这个这不需要改变，所以加上final修饰。 
6、作为常量，敞亮的书写规范所有字母都大写，如果由多个单词组成，单词间通过 _ 连接。 
8、一般是public static final 。。。这么使用。 

 
六抽象类的概述： 

抽象：笼统，模糊，看不懂！不具体。

当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。 

这时，只抽取功能定义，而不抽取功能主体。 

抽象类的特点(abstract)： 
1，方法只用声明没有实现时，该方法就是抽象方法，需要被abstract修饰。 
       抽象方法必须定义在抽象类中。该类也必须被abstract修饰。 
2，抽象类不可以被实例化(也就是创建对象的意思)，为什么？因为调用抽象方法没意义。 
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。 
否则， 这个子类还是抽象类。 

4，抽象类和一般类的异同点。 
相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。 
不同点： 
1，一般类有足够的信息描述事物。 
抽象类描述事物的信息有可能不足。 
2，一般类中不能定义抽象方法，只能定义非抽象方法。 
抽象类中可定义抽象方法，同时也可以定义非抽象方法。 
3，一般类可以被实例化。 
抽象类不可以被实例化。 
5，抽象类一定是父类吗？ 
是的。因为需要子类覆盖其方法后才可以对子类实例化。 
抽象类练习：
/* 
雇员示例： 
需求：公司中程序员有姓名，工号，薪水，工作内容。 
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。 
对给出需求进行数据建模。 
 
分析： 
在这个问题领域中，先找出涉及的对象。 
通过名词提炼法。 
员工：  
属性：姓名，工号，薪水、  
行为：工作。  
经理：  
属性：姓名，工号，薪水，奖金。  
行为：工作。  

class Object1
{
public static void main(String[] args)
{
Pro p=new Pro("zhangsan","23",1000);
p.work();
Manager m=new Manager("zhangsan","23",1000.0,255);
m.work();
}
}
abstract class employee
{
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 Pro extends employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println(name+"pro work");
}
}
class Manager extends employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus=bonus;
}
public void work()
{
System.out.println("manager work");
}
}

员工和经理不存在着直接继承关系， 
 
但是员工和经理却具有共性内容。 
可以进行抽取。因为他们都是公司的雇员  
 
可以将程序员和经理进行抽取.建立体系. 
*/  
  
 
七模版方法设计模式 

1、需求：获取一段程序运行的时间 
2、原理：获取程序开始和结束的时间并相减 
3、获取时间：System.currnetTimeMillis(); 
4、这种方式，叫模板方法设计模式 
5、模板方法设计模式：在定义功能是，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的那部分暴露出去，有该类的子类去完成。 

class Object1
{
public static void main(String[] args)
{
GetTime g=new GetTime();
g.getTime();
}
}
abstract class GetTime
{
public final void getTime()
{
long time1=System.currentTimeMillis();
run();
long time2=System.currentTimeMillis();
long time3=time1=time2;
System.out.println(time3);
}
public abstract run();
}
class SubTime extends GetTime
{
public void run()
{
for(int x=0;x<4000;x++)
{
System.out.println("nihao"+x);
}
}
}

八接口 

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口 interface。 
格式： interface接口名{} 
定义接口使用的关键字不是class，是interface。 
对于接口当中常见的成员：而且这些成员都有固定的修饰符。 
1，全局常量。public static final  
2，抽象方法。public abstract 
由此得出结义，接口中的成员都是公共的权限，都是public。 
 类与类之间是继承关系，类与接口之间是实现关系。 
实现： implements 

Interface Inter
{
public static final int X=3;
public abstract void show();
}
class Test implements Inter
{
public void show()
{
System.out.println("nihao");
}
}
class Object1
{
public static void main(String[] args)
{
Inter i=new Inter();
System.out.println(i.X);
System.out.println(Inter.X);
System.out.println(Test.X);
}
}

注意：接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。 
否则这个子类也是抽象类。 
  
在Java中不直接支持多继承，因为会出现调用的不确定性。 所以Java将多继承机制进行改良，在Java中变成了多实现。 
一个类可以实现多个接口。 接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。 接口的出现避免了单继承的局限性。 类与类是继承关系，类与接口是实现关系，接口与接口之间是继承关系，而且接口可以多继承。 
 注意:接口的出现再次打破了单继承的局限。 

九接口的特点：

 
1，接口是对外暴露的规则。 
2，接口是程序的功能扩展。 
3，接口的出现降低耦合性。 
4，接口可以用来多实现。 

5，类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。 

6，接口与接口之间可以有继承关系。 

十接口与抽象类的异同点： 

相同点：都是不断向上抽取而来的。 
不同点： 
1，抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。 
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。 接口中只能定义抽象方法，必须由子类去实现。 
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。接口的实现是like a关系。