菜鸟java记录五

阅读前文->这是一篇长文；主要记录的是继承，同时完成继承的一些必要概念如接口、抽象类、普通类、方法重写、构造器及在构造器中使用的方法重载等

 

继承

定义： Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类；也就是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力

 

继承分类： 单继承、多重继承（注：由于多继承带来的二义性，所以java中类只支持单继承，即一个类只能有一个父类；但一个类可以有多个接口 ，接口支持多继承；从上可看出java可以通过使用接口机制来实现多重继承）

 

继承的用处：  继承提供了软件复用功能，减少代码冗余

 

了解继承之前先了解 ：1.类的分类

2.类中方法的分类

 

1.类分类

1)普通类

格式：publicclass　文件名{}

特点：普通类中只能定义构造函数和普通方法（如有异议，可以编写测试类测试，下同）

                       属性可以是变量也可以是常量

2)抽象类

格式: public abstractclass 文件名{}

特点：抽象类中允许存在普通方法和抽象方法

                     属性可以是变量也可以是常量

3)接口

格式：public interface 文件名{}

特点：接口中只能有抽象方法

                     属性只能是常量        

2.方法分类

1)        普通方法：     访问权限  返回类型  方法名(参数){}

2)        构造方法：     访问权限  类名(参数){}

3)        抽象方法：     访问权限  abstract  返回类型  方法名();（没有具体方法体）

 

继承关键字：

1.      extends（类继承关键字）extend意为扩展 所以顾名思义子类是对父类进行了扩展

2.      implements（接口继承关键字）

 

其他总结：

1.      继承的关系是可以传递的；若类C继承类B，类B继承类A（多继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法

2.     在继承的时候，访问权限只能扩大或不变，如父类中为protected 则子类中只能为protected或public 一旦申明为private 程序会报错

 

说到继承，不可避免的要说方法的重写 因为 子类会继承父类的所有属性和方法；但我们可能在子类中不想用到父类的那些方法或者不想用父类方法体，这时候我们就会用到方法的重写和构造器

方法重写：

要求：子类重写父类方法：

1.      方法名参数必须相同，访问权限只能扩大不能缩小

2.      重写的方法和原方法要么都是实例方法或者都是类方法，不能一个是实例方法，一个是类方法，否则会引起编译错误

具体要求：

1.  普通类 extends 抽象类      必须同时重写抽象类中的所有抽象方法

2.  普通类 implements 接口    必须同时实现接口中的所有抽象方法

3.  抽象类 implements 接口      无

 

自动转型：

子类对象可以自动转型为父类引用

特点：

             如果子类重写了父类的方法，则转型后的对象执行的还是重写后的方法

方法重写之后：

            子类不能访问父类中已被重写的方法，但子类可以调用父类中被重写的方法；假如重写的是实例方法，就使用super关键字（注：super是直接对父类的引用，并且这一行代码必须出现在构造器的第一行）；如重写的是类构造方法，就使用类名                              

构造器

概念解释：在我们创建对象的时候，系统会将该对象默认分初始化构造，而构造器可以改变这种默认初始化构造

 

作用：创建java对象的重要途径，并执行一些初始化操作

 

示例代码：

public class A{

         publicA(){

//这里可以执行一些需要的初始化

}

}

 

注：       假如构造器之间如果要相互调用，此时当你使用new调用时，会导致系统重新创建一个新的对象，浪费内存；事实上我们可以通过this 来调用构造器 （this调用构造器，只能在构造器中使用，而且是语句的第一条，如：this.super.A（））

（查阅而知）从 注 中可知；当我们使用子类构造器调用父类构造器时会有如下几种情况：

a)   子类构造器的执行体的第一行用super显式调用父类构造器，系统将根据super 调用里传入的实例列表调用父类对应的构造器

b)   子类构造器执行体的第一行是this显式调用本类中重载的构造器，系统根据this调用里传入的实参列表调用本类中另一个构造器，执行本类中另一个构造器时，既会调用父类的构造器。

c)   子类构造器中既没有this,也没有super，系统将会在执行子类构造器之前隐式调用父类无参的构造器

 

在构造器中 我们可以再次申明默认构造函数，来实现在创建对象时完成一些我们想要实现的初始化，同时我们也可以进行 构造函数重载 也就是方法重载

 

方法重载

定义：   在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型、参数的个数或参数定义的顺序；

 

要点：   1.必须是同一个类

                  2.方法名相同

                  3方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。

                                      i.           如果参数个数不同，就不管它的参数类型

                                    ii.           如果参数个数相同，那么参数的类型或者参数的顺序必须不同。

         4. 方法的返回类型、修饰符可以相同，也可不同

5.调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法

 

作用：   传递相应参数，并执行不同方法

注：        Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法。

 

示例代码：  

public class B {

         publicString something;

public B(){

                   System.out.println("构造了一个B对象");

         }

         publicB(String b){

                   something= b;

         }

         publicvoid do_thing(){//显式申明构造函数

                   System.out.println("做了某些事");

         }

         publicvoid do_thing (String something){

                   System.out.println("传了String类型参数的重载");

         }

         publicboolean do_thing (int a){//boolean返回值

                   System.out.println("传了int类型参数的重载");

                   returntrue;

         }

         publicvoid do_thing (String name,int a){

                   System.out.println("参数个数不同的重载");

         }

         publicvoid do_thing (int a,String name){

                   System.out.println("参数顺序不同的重载");

         }

}

 

方法重载与重写的区别：

1.重写是发生在子类和父类的同名方法之间；重载是发生在同一个类得多个同名方法之间。

2.父类方法与子类方法也有可能发生重载，因为子类会获得父类的方法，如果子类定义了一个与父类方法具有相同的方法名，但参数列表不同的方法就会形成父类方法与子类方法的重载

 

继承的示例代码：

/**

 * 生物 类

 */

public classCreatures {

         //一些属性

         public String name;

         public int age;

         //方法

         public Creatures(){//父类构造器            

         }

         public void eat() {

                   System.out.println("吃东西");

         }

}

 

/**

 * 特性 接口

 * 表明一些共有特性行为

 */

public interfaceCharacter{

         public String name = "";

         public abstract void run();

}

packagecom.huaxin.lesson;

/**

 * 人 类

 * 继承了生物类，特性接口

 */

public classPeople extends Creatures implements Character {

        

         public People(){//子类构造器

                   this.super();

                   this.name = "王五";

         }       

         public People(int a){//构造器重载

                   this.super();

                   this.name = "王五";

                   this.age = a;

         }

         public void play() {//人的子类中定义的方法

         }

         public void play(String name) {//重载

         }

         public void play(String name,int a) {

         }

         @Override

         public void run() {//方法重写

                   // TODO Auto-generated methodstub

         }

         public void eat() {//方法重写

                   System.out.println("人吃饭");

         }

}

packagecom.huaxin.lesson;

/**

 * 测试类

 */

 

public class Test{

         public static void main(String[] args){

                   Creatures peo = newPeople();//自动强制类型装换

                   People peo2 = new People(2);

                   peo2.play();

                   peo.play("张三");

                   peo.play("张三",5);

                   peo2.eat();

                   peo.run();

                  

                   Creatures cre = newCreatures();

                   cre.eat();

         }

}

 

 

文章较长，错误难免，有待逐步纠正