C#与java中对抽象类、接口的继承和重写区别

C#：

一、继承

什么是继承：继承是允许重用现有类去创建新类的过程。分类的原则是一个类派生出来的子类具有这个类的所有非私有的属性。
1、继承C#中的类：C#不支持多重继承，C#类始终继承自一个基类（如果未在声明中指定一个基类，则继承自System.Object）。
派生类继承基类的语法如下：
using System;
public class Person
{
//这是基类
}
public class Student:Person
{
//这是派生类
}
注：派生类继承基类时用“：”符号连接，派生类继承基类的所有非私有成员变量和方法。
2、调用基类的构造函数：
如果对类没有定义显式构造函数，则编译器将提供默认的构造函数，以初始化这些类的成员字段。但是，如果显式添加了构造函数，就可以有效控制整个构造过程。
示例：
using System;
namespace Jicheng
{
//基类
public class Person
{
public string  _name;
public uint  _age;
//基类的构造函数
public Person(string name,uint age)
{
this._name = name;
this._age = age;
   //打印输出
Console.WriteLine(_name);
Console.WriteLine(_age);
}
}
//派生类
public class Student:Person
{
private uint _id;
//派生类构造函数并调用基类构造函数用“:base”
public Student(string name,uint age uint id):base(name,age)
{
this._id = id;

//打印输出
Console.WriteLine(_id);
}
}
public class Exercise
{
[STAThread]
static void Main(string[] args)
{
//构造 Student
Student objstudent=new Student(“XYZ”,45,001);
}
}
}
注：派生类通过使用:base（）语法可以显式调用基类的构造函数。在必要的情况下，可以利用它来初始化字段。

二、C#中的方法重写
关键字：override
override关键字用语修改方法，具有override关键字修饰符的方法是对基类中同名方法的新实现，基类中的同名方法必须声明为virtual或abstract类型。给基类中的方法添加virtual关键字表示可以在派生类中重写它的实现。
1、默认的C#方法并非virtual，因此不能重写。
2、基类方法的可访问级别并不因重写它的方法而改变，他们的访问修饰符相同。
3、new、static和virtual关键字不能与override访问修饰符一同使用
关键字：virtual
C#中提供virtual关键字，用语将方法定义为支持多太，用于对一个类中可修改的方法的声明，这种方法称为虚拟方法，字类可以使用override关键字自由实现它们各自版本的虚拟方法
语法：
[访问修饰符] virtual [返回值类型] 方法名称（[参数列表]）
{
  //虚拟方法的实现
}
1、virtual访问修饰符不能与static和override等访问修饰符一同使用
2、调用虚拟方法，在运行时系统会自动检查，以确定调调用了哪一个实现方法。
关键字：new
new访问修饰符用于显式隐藏继承自基类的成员，如果派生类成员与基类成员名称相同，new会将派生类成员识别为一个全新成员。
1、在一个方法中同时使用new和override将会出错。
2、new访问修饰符的真正目的是为了隐藏基类方法。
3、如果将一个方法生命为new，它实际上并没有隐藏基类方法，并且编译器也产生了警告，这时应该删除new。

三、抽象类和抽象方法
什么是抽象类：不能被实例化的类称为抽象类，抽象类是派生类的基类。
关键字：abstract
语法：
abstract class 类名
{
…………
}
1、一个抽象类可以同时包含抽象方法和非抽象方法。
2、抽象方法只在派生类中真正实现，这表明抽象方法只存放函数原型，不涉及主体代码，
3、派生自抽象类的类需要实现其基类的抽象方法，才能实例化对象。
4、使用override关键子可在派生类中实现抽象方法，经override声明重写的方法称为重写基类方法，其签名必须与override方法的签名相同。
示例：
using System;
namespace Example_5
{
//抽象类
abstract class ABC
{
  //抽象方法
  public abstract void Afunc();
}
//派生类
class Derv:ABC
{
  //实现抽象类中的抽象方法
  public override void Afunc()
{
   Console.WriteLine(“实现抽象方法”);
  }
}
public class Test
{
  static void Main(string[] args)
  {
   Derv obj=new Derv();
   obj.Afunc();
  }
}
}
5、基类实现抽象类，则派生类不需要重新实现该抽象类。
6、抽象类并不仅仅只是一种实现技巧，它更代表一种抽象的概念，从而为所有的派生类确立一种约定。

四、接口
关键字：interface
语法：
修饰符 interface 接口名
{
  //接口主体
}
1、一个接口就相当于一个抽象类，但是它不能半喊任何实现方法。
2、接口的每种方法都必须在派生类中实现。
3、接口有时候可以看成是类的模具，它指明一个类该提供哪些内容。
4、接口主体只限于方法、索引器、属性的声明。
5、接口中不能包含字段、构造函数和常量等。
6、接口成员是隐式公开的，如果对其显式指定访问级别，就会出现编译器错误。
7、在接口中不能实现任何方法，属性或者索引器。
8、在指定方法时，只需给出返回类型、名称和参数列表，然后以分号结束。
9、实现接口的语法与实现继承一样，都用冒号“:”
示例
interface Icustomer
{
………………
}
public class MyClass: Icustomer
{
………………
}
10、接口中的方法不能重写，只能实现。
11、
编码标准：
接口名称需始终冠以大写字母I

五、多重接口实现
C#中多重接口的实现，弥补了C#只能单一继承，不能多重继承弱点。
语法示例：
public intetface IName
{
       void Name();
}
public interface IAge
{
void Age();
}
public class Consoleshow: IAge, IName
{
public void Name()
{
//具体实现
}
public void Age()
{
//具体实现
}
}

六、显式接口实现
如果两个接口中有完全相同的签名，那么可以用“接口名.方法名”的方法显式的来实现接口。
示例：
public interface Iname
{
void Test();
}
public interface Iage
{
void Test();
}
public Test: Iname, Iage
{
void Iname Test()
{
// Iname借口的实现
}
void Iage Test()
{
// Iage借口的实现
}

}

七、接口继承
通过合并其他接口，也可以新建接口。用于合并接口的语法于继承的语法非常相似，只是前者可以将多个接口合并成一个。一个类要实现一个接口，必须为基接口和派生借口的所有成员编写代码。

Java：

一。抽象类

有时候，我们可能想要构造一个很抽象的父类对象，它可能仅仅代表一个分类或抽象概念，它的实例没有任何意义，因此不希望它能被实例化。例如：有一个父类“ 水果（Fruit）”，它有几个子类“苹果（Apple）”、“橘子（Orange）”、“香蕉（Banana）”等。水果在这里仅仅只是作为一个分类， 显然水果的实例没有什么意义（就好像一个人如果告诉你他买了一些水果但是却不告诉你是苹果还是橘子，你很难想象他到底买的是什么。）。而水果类又要能被子 类化，这就要求我们使用抽象类（abstract class）来解决这个问题。 
在java中，通过在class关键字前增加abstract修饰符，就可以将一个类定义成抽象类。抽象类不能被实例化。例如： 
          定义抽象类水果（Fruit） 
          public abstract class Fruit { 
                  …… 
          } 
           如果我们试图用以下语句来获得一个实例，将无法编译成功。 
           Fruit fruit = new Fruit(); 
而我们仍然可以构造水果类的子类，如： 
          子类“苹果（Apple）” 
           public class Apple extends Fruit { 
                   …… 
           } 
          子类“橘子（Orange）” 
           public class Orange extends Fruit { 
                   …… 
           } 
这样就达到我们的目的了。 
抽象类除了能象普通类一样可以拥有一般的属性和方法，也可以拥有抽象方法（abstract method）。例如： 
           抽象类“形状（Shape）”拥有抽象方法draw()。 
           public abstract class Shape { 
                  …… 
                  public abstract void draw(); 
                  …… 
           } 
抽象方法与抽象的行为相对应，通常是这个行为对父对象没有意义，而子对象有具体动作。例如方法draw()对于类Shape没有意义，而类 Shape的子类矩形（Rectangle）的方法draw()可以有实际的动作（根据矩形的四个顶点画出矩形的四个边），子类圆（Circle）的方法 draw()也可以有实际的动作（根据圆心和半径画出圆周）。 
抽象类可以有抽象方法也可以没有抽象方法；但是如果一个类有抽象方法，那这个类只能定义为抽象类。 
           如果按照以下代码类“形状（Shape）”仍然拥有抽象方法draw()，但没有定义为抽象类，将会编译失败。 
           public class Shape { 
                  …… 
                  public abstract void draw(); 
                  …… 
           } 
抽象方法还有一个特点是，它强迫子类要么仍然保持抽象性（即不具体实现该方法并仍然定义为抽象类），要么具体表现出这个方法的行为（实现具体的动作或者通过抛出UnsupportedOperationException异常来表明不支持该行为）。这样也可以强化多态性。

 

 

 

二 接口

 

下面谈谈接口（interface）。java语言使用关键字interface定义一个接口。接口也是抽象对象，它甚至比抽象类更抽象。接口中的方法都是抽象方法。 
一个接口可以继承其他接口；一个类通过关键字implements声明要实现一个接口，并具体实现接口的方法。 
           例如：有一个接口InterfaceA， 

Java代码 
public   interface  InterfaceA {    
         void  methodA();    
}   
  
           类ClassA实现接口InterfaceA。 

Java代码 
public   class  ClassA  implements InterfaceA {    
          public   void  methodA() {    
               System.out.println( "methodA of ClassA implements InterfaceA" );    
         }    
}   
  
如果是抽象类实现一个接口，那么抽象类中可以不具体实现接口的方法（保持其抽象性），而由其子类去实现。 
           抽象类ClassB实现接口InterfaceA，但是没有具体实现方法methodA()， 

Java代码 
public   abstract   class  ClassBS  implements InterfaceA{           }   
  
           子类ClassBSub实现接口InterfaceA，但是没有具体实现方法methodA()， 

Java代码 
public   class  ClassBSub implements InterfaceA{    
         public   void  methodA() {    
              System.out.println( "methodA of ClassBSub the subclass of ClassB" );    
        }    
}  

 

接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。 
接口和抽象类的不同点有： 
           (1)抽象类可以有实例变量，而接口不能拥有实例变量，接口中的变量都是静态（static）的常量（final）。 
           (2)抽象类可以有非抽象方法，而接口只能有抽象方法。

 

java允许一个接口继承多个父接口，也允许一个类实现多个接口，而这样的多继承有上面提到的缺点马？ 
答案是没有，这是由接口的抽象性决定的。 
正如前面介绍的，在接口中不能有实例变量，只能有静态的常量，不能有具体的方法（包含方法体），只能有抽象方法，因此也就摒弃了多继承的缺点。 
对于一个类实现多个接口的情况，因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现类的方法（不存在歧义）， 因此不存在多继承的第二个缺点；而又因为接口只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引 用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。 
对于一个接口继承多个父接口的情况也一样不存在这些缺点。 
请看以下示例。 
            接口A： 

Java代码 
public   interface  InterfaceA {    
         int  len =  1 ;    
         void  output();    
}   
  
            接口B： 

Java代码 
public   interface  InterfaceB {    
           int  len =  2 ;    
           void  output();    
}   
  
            接口InterfaceSub继承接口A和接口B： 

Java代码 
public   interface  InterfaceSub  extends  InterfaceA, interfaceB {            }   
  
            类Xyz实现接口InterfaceSub： 

Java代码 
public   class  Xyz  implements  InterfaceSub {    
         public   void  output() {    
                System.out.println( "output in class Xyz." );    
        }    
          public   void  outputLen( int  type) {    
                  switch (type) {    
                          case  InterfaceA.len:    
                                 System.out.println( "len of InterfaceA=." +type);    
                                  break ;    
                          case  InterfaceB.len:    
                                 System.out.println( "len of InterfaceB=." +type);    
                                  break ;    
                 }    
        }    
        public   static   void  main(String[] args) {    
               Xyz xyz=  new  Xyz ();    
               xyz .output();    
               xyz .outputLen();    
       }    
  

           以上代码不存在什么问题，但是如果试图编写以下存在冲突的代码，则会编译失败。 

Java代码 
Xyz xyz =  new  Xyz();    
int  len = xyz.len;    
System.out.println(len);