7继承，覆盖，this super

/*

继承：

1.提高代码的复用性

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

 

 

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

必须是类与类有所属关系才可以继承，所属关系叫is a，谁是谁中的一员

（父类的由来是有子类不断抽取出来的，猫跟人能继承吗，当然不能，但是可以向上抽取他们的共性形成一个类，比如说都能吃，都能睡）

 

 

java语言中，只支持单继承，不能多继承，一个类只能继承一个父类，

因为多继承容易带来安全隐患。当父类中定义了相同功能，但功能内容不同时，多继承就会分不清继承哪一个。

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

eg：

 

clsaa A

{

       void show()

       {

       S.o.p("a");

       }

}

 

clsaa B

{

       void show()

       {

       S.o.p("b");

       }

}

clsaa C extend，A，B；

{}

C c=new c()；

c.show();

问，c都集成了a，b，这样调用输出什么？所以有安全隐患。

*/

/*

java支持多层继承，eg。A继承B，B继承C

也就是一种继承体系，如何使用继承体系中的功能呢？API

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

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

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

那么在具体调用时，要创建最子类的对象，因为1有可能父类不能能闯将对象eg：抽象类。

2是，创建子类可以使用更过的功能，包括基本的也包括特有的

 

 

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

 

*/

 

 

class  Student

{

       public static void main(String[] args)

       {

              System.out.println("Hello World!");

       }

}

 

/*事物和事物不光只有继承关系。

聚集：has a

 

聚合：球队中少了一个球员没关系

 

组合：（紧密联系程度更高）人少了心脏，

*/

 

——————————————————————————————————子父类中变量的变化

/*

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

 

类中成员

1，变量

2，子夫类中的函数

3.构造函数。

 

1，变量

如果子类中出现非私有的同名成员变量时，下面的num和Fu类中的num重名

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

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

 

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

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

super代表着父类对象的引用。

 

2，函数

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

当子类对象调用该函数，只会运行子类函数

如同父类被覆盖一样，（但是父类的方法还在，只不过没运行而已）

 

这种情况叫覆盖（重写）

 

当子类继承了父类，沿袭了父类的功能到子类中，但是虽具备该功能，但是功能的内容

却和父类不一样，这时，没有必要新功能，而是使用覆盖特性，而是保留父类的功能定义

而重写功能内容。

 

一部老手机只可以显示手机号，后来要升级，要显示名字和图片，

不可能去改变一个类中的方法，因为那要修改与之相关的代码。

所以就找个子类去继承他，然后用重写他的那个方法，在里边加上

显示姓名的功能。

 

注意事项：

 

1子类覆盖父类，必须保证子类的权限大于等于父类，才可以覆盖，否则变异失败

2，静态只能覆盖静态。

 

重载：构造函数中，只看函数的参数列表

重载：继承中，子父类方法一摸一样。包括返回值类型

 

 

 

 

*/

class Fu

{

       int num =4;

}

class Zi

{

       int num=5;

       void show()

       {

              System.out.println(super.num);//this.num

       }

}

class ExtendsDemo2

{

       public static void main(String[] args)

 

       {

              Zi z = new Zi();

              z.show();

       }

}

 

/*

 

3，子父类构造函数

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

那是因为子类的构造函数默认第一行有一条隐式的语句 super（）；

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

 

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

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

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

 

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

 

子类的实例化过程：

结论

 

子类所有的构造函数默认都会访问父类中空参数的构造函数。

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

 

当父类中没有空参数的构造函数时，子类必须手动通过super();来访问父类中的构造函数。

 

——————————————————————————————————————————

/*

final (最终的意思)

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

2.被final修饰的类不可以被继承。（因为继承打破了封装性，为了保持它的封装性用final）

3，被final修饰的方法不可以被复写。（比如说一个类中，他的方法有你需要的，但是也有你不需要的，

这时候怎么办呢？你不用继承这个类，只需要用final吧不需要的方法修饰起来就ok）

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

       在描述一些事物时，一些数据的出现时固定的，那么这时候为了增强阅读性，都给这些值起个名字，方便阅读

       当这个值不需要改变，所以加上final，比如final double MY—_PI=3.14；常量书写规范，所有字母都大写，如果由多个单词组成，单词间通过_连接。

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

*/

 

————————————————————————————

/*

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

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

*/

abstract class Student

{

       abstract void study();//抽象方法必须定义在抽象类中

}

 

class BassStudent

{

       void study

       {

              S,o,p("bsse study");

       }

}

class AdvStudent

{

       void study

       {

              S,o,p("sdv study");

       }

}

/*

 

抽象：看不懂

抽象类的特点

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

2，抽象方法和抽象类都必须被absteact修饰

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

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

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

 

抽象类和一般类没有太大的不同，他里边也可以定义非抽象方法，没什么意义，这仅仅是不能让类建立对象

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

这些不确定的功能，需要明确出现，但是无法定义主体，通过抽象方法来表示。

抽象类比一般类多了抽象方法，抽象类不可以实例化。

*/

模板方法设计模式

 

/接口：初期理解，可以认为是一个特殊的抽象类

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

跟定义类差不多，只不过换了interface

接口定义，格式特点

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

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

     常量：public  static  final

     方法：public abstract

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

接口：是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口

中的抽象方法全覆盖后，子类才可以实例化，否则子类是个抽象类

 

/*

Interface Inter

{   

public static final int NUM = 3;

     Public abstract void show();//抽象方法

}/

class  Test  implements  Inter//接口中的另一种关系，叫实现关系，这就是实现，

{

     Public void shou(){}

}

Class InterfaceDemo

{

     public static void main(String[] args)

     {

       Test t = new Text();

       String.out.println(t..NUM);

String.out.println(Test..NUM);

String.out.println(tInter.NUM);

}

}

接口的特点：

           接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现implement

Eg:   class Text implements Inter,InterA//Test类同时实现了两个接口

          

           一个类可以再继承一个类的同时还实现多个接口。

           //class  Test  extends  Demo implements Inter,Intera

           接口之间可以继承，还可以多继承，因为没有方法体。

 

 

 

 

/*需求，一个学生类，定义了学生中共有的方法，学习，睡觉等，但是每个人学习的内容都不一样，莫能两可就用抽象定义方法，然后，张三抽烟，但是别人不抽啊，但是张三也学习啊，于是就把抽烟这个方法定义在接口里，张三这个类就既可以继承学生这个父类，有可以通过接口实现抽烟的方法，李四不抽烟，只学习*/

个人总结，一个父类中，大家都一样的活动就正常定义，大家都有的活动，但是活动内容不一样的，就定义成抽象的，让继承他的类自己创建实例去重写去，而大家都没有的活动，但是某个人有的活动，就定义成接口形式。

 

基本功能

abstract class Student//定义了一个抽象方法，所以他的类是抽象类，

{

abstract void study();//虽然大家都会学习，但是学习的内容不一样呢，定义成抽象的，方便子类调用

void sleep()

{

Systdm.out.println(“sleep”); 

}         

 

Interface Smoking//定义成接口，个别学生才会抽烟呢

{

Void smke();

}

class ZhangSan extends Student implements Smoking//张三因为又具有学生的特点，又抽烟，

{

           void study(){}

           public void Student(){}//所以就继承父类而且实现接口

 

}

class Lisi extents Student//李四就只继承了学生类

{

 

}

class

}