黑马程序员_继承

  ----------------------<ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

 

                                                        黑马程序员_继承

 

/*

继承：

1提高了代码的复用性

2 让类与类之间产生关系。有了这个关系，才有了多态的特性。

注意：千万不要为了获取其他类的功能，简化代码来继承；

必须是类与类之间所属关系才可以继承。

class C

{

         void demo1(){};//找到共性内容提取出来；

}

class A extends C

{

         //void demo1(){};

         void demo2(){};

}

class B extends C

{

         //void demo1(){};

         void demo3(){};  

}

Java语言中：java只支持单继承，不支持多继承

因为多继承容易带来安全隐患：

当多个父类中定义了想通过功能，当功能内容不相同时，

子类对象不确定要运行哪一个。

但是Java保留了这种机制，并用另一种体现形式来完成表示：多实现

java支持多层继承。也即是一个继承体系

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中的共性功能

通过了解共性功能，就可以知道该体系的基本功能

那么这个体系已经可以基本使用了

那么在具体调用时。要创建最子类的对象，为什么呢？

一：因为有可能父类不能创建对象

二：创建子类对象可以用更多的功能，包括基本的也包括特有的。

 

简单一句话：查阅父类功能创建子类对象使用功能

 

 

class A

{

void show()

         {

                   System.out.println("a");

         }

}

class B

{

         void show()

         {

                   System.out.println("b");

         }

}

class extends A,B

{}

C c = new C();

c.show();//此时c就不确定到底打印a还是b

聚集：has a

聚合：

组合

*/

//将学生和工人的共性内容描述提取出来，单独描述

//是要让学生和工人与单独描述的这个类有关系，就可以了

class Person

{

         String name;

         int age;

 

}

class Studentextends Person

{

         void study()

         {

         System.out.println("goodstudy");

         }

}

class Worjerextends Person

{

         void work()

         {

         System.out.prrintln("goodwork");

 

         }

}

class Student

{

         String name;

         int age;

         void study();

         {

         }

}

class Worker

{

         String name;

         int age;

         void Worker();

         {

         }

}

 

 

/*

子父类出现后。类成员的特点

类中成员

1 变量

2 函数

3构造函数

1子父类中的变量

如果子类中出现非私有的同名成员变量时；

子类要访问本类中变量，用this

子类要访问父类中的同名变量，用super

super的使用和this 的使用几乎一致

this代表的是本类对象的引用

super代表的是父类对象的引用、

*/

class Fu

{

         privateint num = 4;

}

class Zi extends Fu

{

         intnum = 5;

         voidshow()

         {

 

         System.out.println(super.num);

         }

}

class ExendsDemo2

{

         publicstatic void main(String[] args)

         {

                   Ziz = new zi();

                   z.show();

         }

}

 

/*

 

2子父类中的函数

 

当子类出现和父类一样的函数时，

当子类对象调用该函数，会运行子类函数的内容

如同父类的函数被覆盖一样

 

这种情况是函数的另一个特性：重写（覆盖）

当子类继承父类，沿袭了父类的功能，到子类中

但是子类具备该功能，但是功能内容却和父类不一样

这时，没有必要定义新功能，而是使用覆盖特性，保留父类功能定义，并重写功能内容

 

覆盖：

1 子类覆盖父类，必须保证子类权限大于父类权限，才可以覆盖，否则编译失败

2静态只能覆盖静态

 

重载：只看同名函数的参数列表

重写：子父类方法要一模一样

 

*/

class Fu

{

         voidshow()

         {

                   System.out.println("fushow");

         }

         privatevoid speak()

         {

                   System.out.println("vb")

         }

 

}

 

class Zi extends Fu

{

         voidspeak()

         {

                   System.out.println("java");

         }

         voidshow()

         {

                   System.out.println("Zishow");

         }

 

}

 

/*

3子父类中的构造函数

在对子类对象进行初始化时，父类构造函数也会运行

那是因为子类构造函数默认第一行有一条隐式的语句句  supre()；

super()：会访问父类参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

 

为什么子类一定要访问父类中的构造函数？

因为父类中的数据子类可以直接获取，所以子类对象啊在建立时，需要先查看父类是如何对这些函数进行初始化值的

所以子类在对象初始化时，要先访问一下父类中的构造函数

如果要访问服了父类中指定的构造函数，可以同过手动定义super语句的方式来指定

 

注意：super语句一定定义在构造函数的第一行

 

子类的实例化过程：

结论；子类的所有的构造函数，默认都会访问父类中空参数的构造函数

因为子类每一个构造函数内的第一行都有一句隐式的super()

 

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数

 

当然：子类中的构造函数第一行也可以手动定义this语句来访问本类中的构造函数

子类中至少会有一个构造函数会访问父类中的构造函数

*/

class Fu

{

         intnum;

         Fu()

         {

                   num= 60;

                   System.out.println("furun");

         }

         Fu(intx)

         {

                   System.out.println("fu..."+x);

         }

}

class Zi extends Fu

{

         Zi()

         {

                   //super();

                   super(4);

                   System.out.println("zirun");

         }

         Zi(int x)

         {

                   this();

                   //super();

                   System.out.println("zi..."+x);

         }

}

class FuZi

{

         publicstatic void main(String[] args)

         {

                   Ziz = new Zi(2);       

         }

}

 

/*

final：最终。作为一个修饰符

1可以修饰类，函数，变量，

2被final修饰的类不可以被继承（继承打破了封装性），为了避免被继承，被子类复写功能

3被final修饰的方法不可以被复写

4被final修饰的变量是一个常量只能被赋值一次，既可以是成员变量又可以修饰局部变量

         当在描述食物时，一些数据的出现值是固定的，这时为了增强阅读性，都给这些值取个名字方便阅读

         而这个值不需要改变，所以加上final修饰。这个名称作为常量：常量的书写规范

         所有字母大写，如果由多个单词组成。单词间通过_连接起来

5内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量

*/

class Demo

{

         finalint x=3;

         publicstatic final double PI =3.14;

         finalvoid show()

         {}

         voidshow2()

         {

                   finalint y = 4;

                   System.out.println(3.14);

         }

}

class SubDemo extends Demo

{

         //voidshow(){}

}

/*

当多个类中出现相同功能，但是功能主体不同

这时可以进行向上抽取，这时，只抽取功能定义，而不抽取功能主体

抽象：看不懂

抽象类的特点：

1 抽象方法一定定义在抽象类中

2抽象方法和抽象类都必须定义被abstract关键字修饰

3抽象类不可以用new创建对象，因为调用抽象方法没有意义

4抽象类中的方法要被抽象，必须由子类复写起所有的抽象方法后，建立子类对象调用

         如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象

 

抽象类和一般类没有太大的不同

该如何描述事物就 如何描述事物，只不过，该事物出现了一些看不懂的东西

这些不确定的部分也是该事物的功能，需要明确出现，但是无法定义主体

通过抽象方法来表示

 

抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法

抽象类不可以实例化

 

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象

*/

abstract class Student//抽象类要定义出来

{

         abstractvoid study();//只抽取功能定义，而不抽取功能主体

                                     //abstrct用来标示这是抽象方法

}

class BaseStudent

{

         voidstudy()

         {

         System.out.println("basestudy");

         }

}

class AdvStudent

{

         voidstudy()

         {

         System.out.println("advstudy");

         }

}

/*

需求：获取一段程序运行的时间

原理：获取程序开始和结束的时间并相减即可

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题

这种方式，模板方法设计模式

什么是模板方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分

那么这时就将不确定的部分暴露出去。

*/

 

abstract class GetTime

{

         publicfinal void getTime()

         {

         longstart = System.currentTimeMillis();

         runcode();

         longend = System.currentTimeMillis();

         System.out.println("毫秒："+(end-start));

         }

         publicabstract void runcode();

}

class SubTime extends GetTime

{       

         publicvoid runcode()

         {

                   for(intx=0;x<4000;x++)

                   {

                            System.out.print(x);

                   }

         }

}

class Test4

{

         publicstatic void main(String[] args)

         {

                   SubTimeg =new SubTime();

                   g.getTime();

         }

}

/*

接口：当抽象类中的方法都是抽象的，那么该类可以通过接口形式来表示

interface 用于定义接口

接口定义，格式特点：

1接口常见定义：常量，抽象方法

2接口中的成员都有固定修饰符

         常量：public static final

         方法：public abstract

记住：接口中的成员都是public

接口是不可以创建对象的，因为有抽象方法

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化

否则子类是一个抽象类

*/

interface Inter

{

         publicstatic final int NUM = 3;

         publicabstract void show();

}

class Test implements Inter//实现

{

         publicvoid show(){};

}

class InterfaceDemo

{

         publicstatic void main(String[] args)

         {

                   Testt = new Test();

                   System.out.println(t.NUM);

                   System.out.println(Test.NUM);

                   System.out.println(Inter.NUM);

         }

}

 

 

 

 

/*

接口的特点

1接口是对外裸露的规则

2接口是程序的功能扩展（降低耦合性）

3接口可以用来多实现

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

5接口与接口之间可以有继承关系

*/

 

 

 

 

 

 

 

 

 

 

 

 

 

 

---------------------- <ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------