继承，抽象与接口

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一继承概述： 

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语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。 
[java] view plain copy
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，抽象类一定是父类吗？ 
是的。因为需要子类覆盖其方法后才可以对子类实例化。 
抽象类练习：
 
  
 
七模版方法设计模式 


1、需求：获取一段程序运行的时间 
2、原理：获取程序开始和结束的时间并相减 
3、获取时间：System.currnetTimeMillis(); 
4、这种方式，叫模板方法设计模式 
5、模板方法设计模式：在定义功能是，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的那部分暴露出去，有该类的子类去完成。 
[java] view plain copy
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<</span>4000;x++)  
{  
System.out.println("nihao"+x);  
}  
}  
}  




八接口 


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

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------