(邓爱萍)Java抽象继承接口

最新推荐文章于 2022-05-25 14:22:18 发布

wangchuang2017

最新推荐文章于 2022-05-25 14:22:18 发布

阅读量166

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u010608296/article/details/110796435

版权

Java 专栏收录该内容

60 篇文章 1 订阅

订阅专栏

包

Javac –d

package addpack ;
public class IntegerAdd
{
public int addInt(int a,int b)
{ return a+b; }
}
import java.util.Scanner;
public class AddApp{
public static void main(String[]args){
Scanner scanner = new Scanner(System.in);
int a,b;
addpack.IntegerAdd ia= new addpack.IntegerAdd();
System.out.println("Enter two Integers: ");
a=scanner.nextInt();
b=scanner.nextInt();
System.out.println("Output: " +ia.addInt(a,b));
}
}

package addpack ;
public class IntegerAdd
{
    public int addInt(int a,int b)   
                 {   return a+b;   }
}

import java.util.Scanner;
public class AddApp{
 public static void main(String[]args){
    Scanner scanner = new Scanner(System.in);
    int a,b;
   addpack.IntegerAdd ia= new addpack.IntegerAdd();
    System.out.println("Enter two Integers: ");

a=scanner.nextInt();
b=scanner.nextInt();

System.out.println("Output: " +ia.addInt(a,b));
}
}

1.Java语言使用了单继承，每个类只能有一个超类

2.在发生继承时，一个子类对于超类的继承表现在以下几个方面：

1. 一.继承超类的 属性
2. 二.继承超类的 方法
3. 三.使用超类的 构造函数

一．隐藏超类的域(成员变量)

子类继承父类的优点之一：子类可以从父类继承所有的非私有域，并拥有对它们进行直接访问和修改的权限
当子类中定义了和超类同名的成员变量时，在子类引用该变量名时，使用的总是子类自己的定义，而来自超类的成员变量被隐藏。
发生域的 隐藏时，，父类的域被隐藏起来，不能直接访问。

子类和父类的域名必须相同，，域的类型可以不同

一个是子类继承自父类的变量，一个是子类自己定义的变量。这两个成员变量名称相同，但是代表完全不同的变量。

当执行子类从父类继承的方法时，方法内处理的是继承自父类的变量；

当执行子类定义的方法时，方法内处理的是自己的成员变量。

二.覆盖超类的方法

1.子类总是比超类内容要多一些，这反映了它们之间的扩展关系，主要体现在两个方面：
1. 子类在继承超类定义的同时，可以添加属于子类特有的属性、方法和构造函数。
2. 子类在继承超类定义的同时，可以重新修改超类中原有定义的属性和方法，这种现象称为覆盖。
2.覆盖 超类的方法

（1）

1.方法名相同

2.方法返回值类型相同

3.参数表相同 （参数的个数 顺序 参数的类型必须完全相同）

如果1方法名相同，3不同==这两个方法是不同的方法 方法的重载

如果1方法名相同 3参数表相同 2不同 编译错误

（2）方法的访问范围，可以不变、扩大，不可缩小。

例如某个超类的方法的访问控制修饰符是protected，而子类中为public。

（3）无法重新定义Static方法

（4）子类覆盖了超类的某些方法，并不意味着继承于超类的原方法就不存在了，实际上还存在，通过特殊的方法可以使用，但对于通过子类的对象调用这个同名的方法时，只能使用新的方法。

三．super

当前对象的 直接父类

1. 访问直接父类中被隐藏的域和被子类覆盖的方法
1. 在子类中调用被重写的超类方法
  - super.方法名(……)
2. 在子类中引用被隐藏的超类属性
  - super.属性名
2.使用super访问 超类的构造方法
1. 调用直接父类的构造方法，对父类中的成员进行初始化
2. 构造方法不同于一般的方法，子类无法继承超类的构造方法，子类必须有自己的构造方法，但可以使用父类的构造方法，
3. 形式是： super(x,…);
4. 只能在子类的构造方法中 调用 父类的构造方法，而且必须是第一条语句

1.无参数构造方法：创建子类对象实例时，，系统可以 自动调用 父类的无参数构造方法，初始化父类的数据

2.有参数构造方法：父类中的有参数构造方法，系统不能自动调用；只能通过在子类中构造方法中使用关键字super

3.子类创建对象时，不是立即运行自己的构造方法，而是首先调用父类的构造方法，然后才调用自己的构造方法。

class SuperClass{

    int x=2;

    SuperClass(){
       x=2;

    }

    SuperClass(int x){

       this.x=x;

    }

}

class SubClass extends SuperClass{
    double d;
    SubClass(){
       d=0;
    }

    SubClass (double dx){
       super();
       d=dx;
    }

       SubClass (int i,double dx){
        //     super(i);

//     d=dx;

           this(dx);
           x=i;

    }

}

public class ConstruApp {
    public static void main(String[] args) {
 
       SubClass b1=new SubClass();
       SubClass b2=new SubClass(3.54);
       SubClass b3=new SubClass(20,78.97);

    System.out.printf("对象b1的域x和d的值分别为：%2d,%2.2f",b1.x,b1.d);
       System.out.println();

    System.out.printf("对象b2的域x和d的值分别为：%2d,%2.2f",b2.x,b2.d);
       System.out.println();

    System.out.printf("对象b3的域x和d的值分别为：%2d,%2.2f",b3.x,b3.d);
       System.out.println(); 

    }
}

class SuperClass{

int x=2;

SuperClass(){

x=2;

}

SuperClass(int x){

this.x=x;

}

class SubClass extends SuperClass{

double d;

SubClass(){

d=0;

}

SubClass (double dx){

super();

d=dx;

}

SubClass (int i,double dx){

// super(i);

// d=dx;

this(dx);

x=i;

}

public class ConstruApp {

public static void main(String[] args) {

SubClass b1=new SubClass();

SubClass b2=new SubClass(3.54);

SubClass b3=new SubClass(20,78.97);

System.out.printf("对象b1的域x和d的值分别为：%2d,%2.2f",b1.x,b1.d);

System.out.println();

System.out.printf("对象b2的域x和d的值分别为：%2d,%2.2f",b2.x,b2.d);

System.out.println();

System.out.printf("对象b3的域x和d的值分别为：%2d,%2.2f",b3.x,b3.d);

System.out.println();

}

四．抽象类

从Java语法上讲，抽象类是一种不能被直接实例化的类，如下面的类就是一个抽象类：

public abstract class Figure{

String color；

String getColor（）{

return this.color;

}

public abstract double getArea();

}

用abstract关键字来修饰的类被称为抽象类。它不能被直接实例化。

因为抽象类无法直接创建具体的实例对象，它只能作为其他类的 父类

所以在实际中，抽象类只是对某些具有相似性但又有一定区别的类型做成一个更高的抽象，抽象机制使得我们可以用从更高的角度来研究对象间的普遍性。

抽象类中定义了抽象方法----方法头定义； 子类—方法体实现

子类继承 抽象类，并实现 父类的抽象方法后，便能够 实例化 子类对象

可作为类型声明变量，具体实例创建时，需用非抽象子类的实例：
1. Student student = new Postgraduate();
抽象类的实现

抽象类中定义了抽象方法-，它没有具体实现。（父类的）抽象方法的实现在子类中实现。

子类不是抽象类，，子类必须实现父类的 所有抽象方法

抽象方法

用abstract来修饰的方法被称为抽象方法。

抽象方法只需声明，无需实现；只有方法头定义，没有方法体实现

抽象方法 必须在抽象类中 定义

一般方法 必须有方法体的 实现

有抽象方法的类必须为定义为抽象类,而抽象类中可以没有抽象方法。
抽象方法不能用private来修饰
访问控制修饰符的组合顺序没有前后之分。

继承抽象类的非抽象子类中不允许出现抽象方法

五．接口多重继承

接口定义
1. 在Java语言中就是一组没有具体实现的方法的集合。

任何一个类都可以实现一个或多个接口所定义的抽象方法。

通过使用接口，可以将功能说明从实现中分离出来。

接口的声明

[public] interface 接口名 [ extends 父接口 [,…] ]{

常量声明;

type methodName1(…);

type methodName2(…);

}

接口的实现

[public] class 类名 extends 父类名 implements 接口列表{

…

}

1. 一个类可以实现多个接口，多个接口逗号隔开。
2. 由于接口中的方法都是抽象的。如果一个非抽象类实现了某个接口，该类必须实现 接口中定义的 所有抽象方法
一个接口，声明它的访问范围为public，可以被任何类所实现，如果采用缺省方式，则只有和接口同在一个包内的类所实现。

每个类只可以有一个超类，但是一个接口却可以有多个父接口(用逗号分割)，当然也可以没有。

一个接口内部可以包括多个常量，供实现接口的类使用，常量的类型默认总是"public static final"。

接口中的抽象方法不能包含具体实现代码，因此，接口中的方法声明没有"{…}",而且方法的默认访问属性就是"public abstract"。

1.三个接口

public interface Music {

public abstract void listenMusic();

}

public interface Message {

public abstract void getMessage();

}

public interface Video {

public abstract void watchVideo();

}

2.一个抽象父类

public abstract class Chair {

public abstract void sit();

}

3.一个实现类

public class MultiChair extends Chair implements Music,Message,Video {

int sitTime;

public MultiChair(int time){

sitTime=time;

}

public void sit() { System.out.println("在椅子上休息"+sitTime+"分钟");}

public void listenMusic () { System.out.println("1-在椅子上 Music");}

public void getMessage() { System.out.println("2-在椅子上按摩服务");}

public void watchVideo() { System.out.println("3-在椅子上看会影碟video");}

}

4.测试类

public class Test {

public static void main(String[] args) {

// TODO Auto-generated method stub

MultiChair m=new MultiChair(30);

m.sit();

m.listenMusic();

m.getMessage();

m.watchVideo();

}

2.接口中的抽象方法实现类要实现抽象方法

public interface Action {

int i=10;

void doAction(); //抽象方法

}

public class Happy implements Action{ // 类实现接口

public void doAction(){ System.out.println(" 做做做。。");} //抽象方法的实现

public static void main(String[] args) {

// TODO Auto-generated method stub

Happy h=new Happy();

h.doAction();

}

3. 实现多个接口

interface I1 { abstract void test(int i); }

interface I2 { abstract void test(String s); }

public class I3 implements I1, I2 {

public void test(int i) {

System.out.println("In I1.test"+i);

}

public void test(String s) {

System.out.println("In I2.test"+s);

}

public static void main(String[] a) {

I3 t = new I3();

t.test(42); t.test("Hello");

}

wangchuang2017

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
(邓爱萍)Java抽象继承接口

包Javac –dpackage addpack ;public class IntegerAdd{public int addInt(int a,int b) {return a+b;}}import java.util.Scanner;public class AddApp{public static void main(String[]args){Scanner scanner = new Scanner(Syst...
复制链接

扫一扫