5 Java基础 继承 接口

/*

将学生和工人的共性描述提取出来，单独进行描述

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

 

继承

1 提高了代码的复用性

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

 

 

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

必须是类与类之间有所属关系才可以继承所属关系 is a .

 

 

calss C

{

         voiddemo1(){}

        

}

 

calss A extends C

{

         //voiddemo1(){}

         coiddemo2(){}

}

 

calss B extends C

{

         //voiddemo1(){}

         voiddemo3(){}

}

若果继承 B中有demo2 但是不应该有demo2 所以不应该继承A

所以去找共性继承C

现有父类后有子类

 

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

 

 

因为多继承容易带来安全隐患  ：当多个父类中定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个

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

 

 

Java支持多层继承 也就是一个继承体系

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

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

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

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

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

1有可能父类不能创建对象

2创建子类对象可以使用更多功能  包括基本的也包括特有的

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

 

class A

{

         viodshow()

         {

     System.out.println("a");

         }

}

calsss B

{

 

         viodshow()

         {

     System.out.println("b");

         }

}

calsss C

{

 

         viodshow()

         {

     System.out.println("c");

         }

}

 

*/

 

 

 

class Person

{

         Stringname;

         intage;

}

class Student extends Person

{

         voidstudy()

         {

                   System.out.println("goodstudy");

         }

}

class Worker extends Person

{

         voidstudy()

         {

                   System.out.println("goodwork");

         }

}

 

class Extendsdemo

{

         publicstatic void main(String[] args)

         {

                   Students=new Student();

                   s.name="zhangsna";

                   //System.out.println("HelloWorld!");

         }

}

 

2

/*

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

类中成员

1变量

2函数

3构造函数

 

 

1变量

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

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

父类要访问本类中的变量用super

 

 

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

super代表的父类对象的引用

 

 

*/

 

 

class Fu

{

         intnum=4;

}

class Zi extends Fu

{

         intnum=5;

         voidshow()

         {

                   System.out.println(super.num);

         }

}

 

//this 本类对象引用 super 父类对象引用

 

class Extendsdemo2

{

         publicstatic void main(String[] args)

         {

                   Ziz=new Zi();

                   z.show();

                   System.out.println(z.num+"...."+z.num);

         }

}

 

 

/*

子父类中的函数

 

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

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

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

 

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

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

但是子类虽具备该功能但是功能的内容却和父类不一致

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

 

覆盖：

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

2静态只能覆盖静态

 

 

记住：

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

重写子父类方法要一摸一样

*/

class Fu

{

 

         voidshow()

         {

                   System.out.println("fushow");

         }

         voidspeak()

         {

                   System.out.println("vb");

         }

 

}

class Zi extends Fu

{

         voidspeak()

         {

                   System.out.println("java");

         }

         voidshow()

         {

                   System.out.println("zishow");

         }

}

 

 

 

class Extendsdemo3

{

         publicstatic void main(String[] args)

         {

                   Ziz=new Zi();

                   z.show();

             z.speak();         

         }

}

 

 

class Tel

{

         voidshow()

         {

                   System.out.println("number");

         }

 

        

}//修改以往的源码绝对是灾难

class NewTel extends Tel

{

  void show()

         {

                   //System.out.println("pic");

                   super.show();

                   System.out.println("name");

                   System.out.println("number");

   }

}//升级 可以继承 覆盖

 

 

/*

3 子父类中的构造函数

 

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

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

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

 

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

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

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

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

 

 

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

 

子类的实例化过程

 

 

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

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

 

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

 

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

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

 

为什么this super不能同时出现在第一行因为初始化动作要先执行

 

*/

 

class Fu //extends Object

{

         intnum;

         Fu()

         {

                   //super();

                   num=60;

                   System.out.println("furun");

         }

         Fu(intx)

         {

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

         }

 

}

class zi extends Fu

{

         zi()

         {

                   //super(4);手动访问

                   //super();隐（藏显）示语句

                   System.out.println("zirun");

         }

         zi(intx)

         {

                   this();//写这个语句就说明没有super语句了在第一行只能存在一种this（super）

                  

                   //super(4);手动访问

                   //super();隐（藏显）示语句

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

         }

 

}

 

 

 

 

class Extendsdemo4

{

         publicstatic void main(String[] args)

         {

                   ziz=new zi();

                   ziz1=new zi(4);

 

                   //System.out.println("HelloWorld!");

         }

}

/*

class Person

{

         Stringname;

         Person(Stringname)

         {

                   this.name=name;

         }

         voidshow(){}

 

}

class Student extends Person

{

         Student(Stringname)

         {

                   super(name);

         }

         voidmethod()

         {

                   super.show();

         }

}*/

 

 

/*

final:最终 作为一个修饰符

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

2被final修饰的类不可以被继承 为了避免被继承，被子类复写功能

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

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

  当在描述事物时，一些数据的值是固定的 那么这时为了增强阅读性，都给这些值七个名字方便与应用

 而这个值不需要改变 所以加final修饰 作为常量：常量的书写规范所有字母都大写，如果有多个单词组成

 单词间通过——连接

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

 

类有两个修饰符了 public权限 final 锁定

*/

 

/*class demo

{       

         voidshow()

         {}

        

}

 

class a extends demo//不可以继承，出错

{

         voidshow()

         {}

}*/

 

class demo

{

         finalint x=3;

 

         staticfinal double MY_PI =3.14;//final固定数据static 共享public 权限够大

        

         finalvoid show1()

         {

 

         }

         voidshow2()

         {

                   finalint y=4;

                   //y=4;//提示错误 ，不可以再次为y赋值

 

                   System.out.println(3.14);

         }

        

}

 

class a extends demo

{

         //voidshow1()//错误不可以覆盖demo中的show1

         {}

}

 

 

 

class Finaldemo

{

         publicstatic void main(String[] args)

         {

                   System.out.println("HelloWorld!");

         }

}

 

 

/*

Object 是所有对象的直接后者或父类

该类中定义的肯定是所有对象都具备的功能

 

Object类中已经提供了对对象是否相同的比较方法

如果自定义中也有比较相同的功能，没有必要重新定义。

只要沿袭父类的功能，建立自己特有比较内容即可这既是覆盖

*/

 

class Demo//extends Object

{

         privateint num;

         Demo(intnum)

         {

                   this.num=num;

         }

         publicboolean equals(Object obj)//Object obj=new Demo();

         {

                   if(!(obj instanceof Demo))

                   {

                            returnfalse;

                   }

                   Demod=(Demo)obj;

                   returnthis.num==d.num;

         }

/*     publicboolean compare(Demo d)

         {

                   returnthis.num==d.num;

         }

*/

 

         publicString toString()

         {

                   return"demo:"+num;

         }

 

}

class Person

{

}

 

 

class Objectdemo

{

         publicstatic void main(String[] args)

         {

                   Demod1=new Demo(4);

                   Demod2=new Demo(7);

 

                   System.out.println(d1.toString());

                   System.out.println(d2.toString());

 

 

//               Classc=d1.getClass();

//               System.out.println(c.getName());

 

//               System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));

//               System.out.println(d1.toString());

 

 

         //      System.out.println(d1.equals(d2));

 

 

         //      Persom p=new Person();

         //      System.out.println(d1.equals(p));//不同类

 

         //      System.out.println(d1.compare(d2));

 

/*

                   Demod1=new Demo();

                   Demod2=new Demo();

                   Demod3=d1;

                   System.out.println(d1.equals(d2));//比较地址值

                   System.out.println(d1.equals(d3));

                   System.out.println(d1==d2);

                   System.out.println(d1==d3);

 

                   */

         }

}

 

 

/*

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

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

 interface用于定义接口

 class用于定义类

 

接口定义时，格式特点：

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

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

  常量：publicstatic final

 

  方法：publicabstract

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

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

子类才可以实例化否则子类是一个抽象类

 

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

接口接口之间是实现关系

 

*/

interface Inter

{

         publicstatic int NUM=3;//interface 成员都有固定修饰符，public static abstract 这些都可以省略但最好不要省

 

         publicabstract void show();

 

}

interface InterA

{

public abstract void show();

 

}

 

class demo

{

         publicvoid function(){}

}

class Test extends demo implementsInter,InterA//先继承后实现

{

         publicvoid show(){}

        

}

interface A

{

         voidmethodA();

         //intshow();

}

interface B //extends A

{

         voidmethodB();

         //booleanshow();//不可以 C继承A,B时不确定继承那个所以不能这样写代码

 

}

interface C extends B,A

{

         voidmethodC();

}

class D implements C

{

         publicvoid methodA(){}

         publicvoid methodB(){}

         publicvoid methodC(){}

}

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抽象方法和抽象类都必须被abstract 关键字修饰

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

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

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

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

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

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

通过抽象方法来表示

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

抽象类不可以实例化

 

 

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

 

*/

 

 

abstract class Student

{

         abstractvoid study();//abstract看不懂的方法

   //abstract void study1();

         voidsleep()

         {

                   System.out.println("躺着");

         }

}

 

class Chongcistudent extends Student

{

         voidstudy()

         {

                   System.out.println("chongcistudy");

 

         }

}

class Basestudent extends Student

{

         voidstudy()

         {

                   System.out.println("basestudy");

 

         }

         //voidstudy1(){}//如果不抽象必须复写父类中所有方法

}

class Advtudent extends Student

{

         voidstudy()

         {

                   System.out.println("advstudy");

 

         }

}

 

class Abstractdemo

{

         publicstatic void main(String[] args)

         {

                   //newStudent();//错误 student方法时抽象方法不可以被调用

 

                   newBasestudent().study();

         }

}