协办模拟 Java(二)面向对象

平、方法函数

函数也称方法,就是概念在接近吃的装有特定功能的均等段子独立代码。用于定义功能,提高代码的复用性。

函数的特点 1> 定义函数可以将力量代码进行打包,便于对该功能进行复用;
2> 函数只有被调用才见面让实施;
3>
对于函数没有现实返回值的事态,返回值类型用要字void代表,那么该函数中的return语句如果在结尾一执得省略不写,系统会赞助你活动抬高;
4> 函数着只能调用函数,不可以在函数内部定义函数。

  修饰符  返回值类型  方法名(参数类型 形式参数1,参数类型 形式参数2,..)
  {  
    方法体;
    return 返回值;
  }

//修饰符: 可选,告诉编译器如何调用该方法。定义了该方法的访问类型。
//返回值类型:函数运行后的结果的数据类型
//参数类型:形式参数的数据类型

 

主函数 main(): 1> 保证此类的独自运转;
2> 程序的入口,自动调用;
3> jvm调用。

 

函数的重载 (overload)

重载的定义:
  以跟一个类似吃,允许存在一个以上的同名函数,只要她的参数个数或者参数类型不同即可。
重载的性状:
  与归值类型无关,只拘留参数列表。
重载的利益:
  方便于阅读,优化了先后设计。Java编译器根据办法签名判断哪个方法应该于调用。

哟时候用重载?

  当定义之法力雷同,但参与运算的不解内容不一。

  那么,这时便定义一个函数名称为表示从效,方便阅读,而通过参数列表的例外来分别多独同名函数。

     
重载的法要拥有不同之参数列表。你不克就依据修饰符或者返回路的差来重载方法。

重载示例:
  返回两只整数的同
    int add(int x,int y){return x+y;}
  返回三独整数的跟
    int add(int x,int y, int z){return x+y+z;}
  返回两单小数的及
    double add(double x,double y){return x+y;}

 

// 重载区分, 重载和返回值类型没关系
void show(int a,char b,double c){}

a. void show(int x,char y,double z){}//没有,因为和原函数一样。
b. int show(int a,double c,char b){} //重载,因为参数类型不同。
c. void show(int a,double c,char b){}//重载,因为参数类型不同。

 

C++ 1C++ 2

public class functc {
    public static void draw(int row, int col){
        for (int i=0; i<row; i++){
            for (int n=0; n<col; n++){
                System.out.print('@');
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        draw(5, 9);
    }
}

打印一个二维数组

C++ 3C++ 4

public class funcsj {
    }
    public static void main(String[] args) {
        print99();
    }

    public static void print99(){
        for (int i=1; i<10; i++){
            for (int n=1; n<i+1; n++){
                System.out.print(n+"*"+i+"="+i*n+" ");
            }
            System.out.println();
        }
    }
}

// 结果
1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

打印一个99随着法表

C++ 5C++ 6

public class funcol {
    public static void main(String[] args) {
        int num = add(5, 8, 9);
        System.out.print(num);    //22
    }
     public static int add(int x,int y){
         return x+y;
     }
     public static int add(int x,int y,int z){
         return add(x,y)+z;
     }
}

函数重载

 

构造方法

当一个目标吃创造时候,构造方法用来初始化该目标。构造方法和她所在类的名字同样,但构造方法没有回去值。

普通会用构造方法给一个近似的实例变量赋初值,或者实施另外必要的手续来创造一个完整的目标。

任凭你吗自定义构造方法,所有的近乎都起构造方法,因为Java自动提供了一个默认构造方法,它将拥有成员初始化为0。

倘而定义了和睦之构造方法,默认构造方法就见面失效。

public class myfunc {
    int x;
    myfunc(int i){
        x = i;
    }
}

C++ 7C++ 8

// myfunc.java

public class myfunc {
    int x;
    myfunc(int i){
        x = i;
        System.out.println(x);
    }
}


// MyDemoTest.java

public class MyDemoTest {
    public static void main(String args[]) {
        myfunc t1 = new myfunc(9);
        myfunc t2 = new myfunc(5);
        System.out.println(t1.x + " " + t2.x);
      }
}

// 输出结果
9
5
9 5

构造方法实例

 

可是变换参数

JDK 1.5 开始,Java支持传递和种的可变参数为一个法。

于道声明中,在指定参数类型后加一个省略号(…) 。

一个道被不得不指定一个唯独转换参数,它要是措施的说到底一个参数。任何一般的参数必须以它之前宣称。

//typeName... parameterName
public static void My( double... nums){...}

C++ 9C++ 10

public class myfunc {

    public static void printNum( double... numbers) {         
        double result = numbers[0];
        System.out.println("The value index eq 0: " + result);

        for (int i = 1; i <  numbers.length; i++){
            System.out.println("The value is " + numbers[i]);
        }
    }

    public static void main(String args[]) {
      // 调用可变参数的方法
        printNum(1, 2, 9, 5, 8);
        printNum(new double[]{1, 2, 6});
     }

}


// 输出结果
The value index eq 0: 1.0
The value is 2.0
The value is 9.0
The value is 5.0
The value is 8.0
The value index eq 0: 1.0
The value is 2.0
The value is 6.0

不过变换参数实例

 

finalize() 方法

Java
允许定义这样的方,它于靶吃垃圾收集器析构(回收)之前调用,这个方法叫做
finalize( ),它用来解回收对象。

比如,你可以下 finalize() 来确保一个目标打开的公文给关了。

在 finalize() 方法里,你要指定在靶销毁时候如果履的操作。

finalize() 一般格式是:

protected void finalize()
{
   // 在这里终结代码
}

根本字 protected 是一个限定符,它确保 finalize()
方法不见面为该类以外的代码调用。

当然,Java 的内存回收可由 JVM
来自动完成。如果你手动使用,则可采取方面的措施。

C++ 11C++ 12

public class myfunc {    
    public static void main(String args[]) {
        Cake c1 = new Cake(1);  
        Cake c2 = new Cake(2);  
        Cake c3 = new Cake(3);  

        c2 = c3 = null;  
        System.gc(); //调用Java垃圾收集器
     }
}



class Cake extends Object {  
      private int id;  
      public Cake(int id) {  
        this.id = id;  
        System.out.println("Cake Object " + id + "is created");  
      }  

      protected void finalize() throws java.lang.Throwable {  
        super.finalize();  
        System.out.println("Cake Object " + id + "is disposed");  
      }
}

// 输出结果
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed

finalize() 方法实例

 

次、修饰符类型

public 类:类属变量和智,包内和包外的另外像样都好拜;
protected
类:
类属变量和方式,包内的任何类,及包外的那些继承了此类的子类才会看;
private 类:类属变量和措施,包内包外的其它像样都无克看;
friendly
类:
类属变量和智不以上就三种植修饰符来修饰,那么包内的旁类似都可看它,而包外的其他类似都未克看它(包括包外继承了此类的子类),因此,这种类似、类属变量和艺术对包内的别样类似是好之,开放之,而针对性包外的外类似是倒闭的。

类:

访问修饰符 修饰符 class 类名称 extends 父类名称 implement 接口名称
(访问修饰符与修饰符的位置可以互换)

访问修饰符

名称

说明

备注

public

可叫所有类访问(使用)

public类必须定义在跟类名相同的同名文件被

package

得吃与一个包中的切近看(使用)

默认的顾权限,可以概括此重要字,可以定义在同public类的跟一个文书被

修饰符

名称

说明

备注

final

采用是修饰符的好像不能够吃连续

 

abstract

而如采用abstract类,之前要首先建一个连续abstract类的新类,新类中贯彻abstract类中的空洞方法。

类设来一个abstract方法,类就非得定义也abstract,但abstract类不肯定不要保护abstract方法不可

 

变量:

l         Java中绝非全局变量,只有方法变量、实例变量(类吃的非静态变量)、类变量(类中的静态变量)。

l         方法吃之变量不克起看修饰符。所以下访问修饰符表仅针对为在接近中定义之变量。

l         声明实例变量时,如果没有赋初值,将给开化为null(引用类型)或者0、false(原始类型)。

l         可以由此实例变量初始化器来初始化较复杂的实例变量,实例变量初始化器是一个所以{}包含的语句块,在接近的构造器被调用时运行,运行为父类构造器之后,构造器之前。

l         类变量(静态变量)也得经类似变量初始化器来开展初始化,类变量初始化器是一个就此static{}包含的语句块,只或受初始化一潮。

 

顾修饰符

名称

说明

备注

public

得被另外类似看

 

protected

好叫同包吃的所有类访问

可让所有子类访问

子类没有当平包中为可以拜

private

但会让当下看似的办法访问

 

缺省

无访问修饰符

可被同包被的所有类访问

倘子类没有以跟一个包中,也不能够访问

修饰符

名称

说明

备注

static

静态变量(又称为类变量,其它的名叫实例变量)

足被类的兼具实例共享。

并不需要创建类的实例就足以看静态变量

final

常量,值只能够分配一赖,不克更改

在意不要动const,虽然她同C、C++中的const关键字含义一样

好跟static一起使用,避免对类的每个实例维护一个正片

transient

报告编译器,在近似对象序列化的时节,此变量不待坚持不懈保存

要害是坐改变量可以透过外变量来获取,使用其是为了性的题目

volatile

指出可能来差不多只线程修改者变量,要求编译器优化以担保对是变量的改能够给科学的拍卖

 

 

方法:

访问修饰符 修饰符 返回类型 方法名称(参数列表)throws 违例列表

l         类的构造器方法无克来修饰符、返回路以及throws子句

l         类的构造器方法给调用时,它首先调用父类的构造器方法,然后运行实例变量和静态变量的初始化器,然后才运行构造器本身。

l         如果构造器方法无显得的调用一个父类的构造器,那么编译器会自动吗她助长一个默认的super(),而而父类又尚未默认的管参数构造器,编译器就见面报错。super必须是构造器方法的率先单子句。

l         注意了解private构造器方法的使技术。

拜修饰符

名称

说明

备注

public

足自所有类访问

 

protected

可以于同一包被之所有类访问

得给有着子类访问

子类没有当同一包着也可看

private

仅仅能够给当下相仿的计访问

 

缺省

无访问修饰符

得吃同一包着之所有类访问

比方子类没有在和一个包中,也非可知顾

修饰符

名称

说明

备注

static

静态方法(又叫做类措施,其它的叫实例方法)

提供免负让类实例的劳动

并不需要创建类的实例就可拜静态方法

final

提防其他子类重载该方法

注意不要采用const,虽然她同C、C++中的const关键字含义一样

足跟static一起用,避免对类的每个实例维护一个正片

abstract

虚幻方法,类吃既扬言如并未实现之不二法门

切莫可知以static方法、final方法要类的构造器方法声明也abstract

native

从而该修饰符定义的点子在类似吃从来不实现,而大部分情形下该方式的贯彻是用C、C++编写的。

参见Sun的Java
Native接口(JNI),JNI提供了运行时加载一个native方法的贯彻,并以其让一个Java类似涉的效益

synchronized

多线程的支持

当一个是措施吃调用时,没有任何线程能够调用该方式,其它的synchronized方法吗不能够调用该办法,直到该法返回

 

接口:

看修饰符 interface 接口名称 extends 接口列表

l         接口不克定义其声明的法门的外实现

l         接口中的变量总是要定义也“public static
final 接口名称”,但可无包含这些修饰符,编译器默认就是这般,显示的含有修饰符主要是为程序清晰

做客修饰符

名称

说明

public

所有 

无访问修饰符(默认)

跟一个包内

 

老三、类的累

继续的表征:

  • 子类拥有父类非private的性,方法与构造器。

  • 子类可以拥有好之习性和方式,即子类可以本着父类进行扩张。

  • 子类可以为此好的方实现父类的法。

  • Java的持续是单继承,但是得基本上又继承,单继承就是一个子类只能继续一个父类,多更继承就是,例如A类继承B类,B类继承C类,所以照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别为C++继承的一个风味。

  • 增强了近似中的耦合性(继承的短,耦合度高饶会见招代码之间的联络)。

 

关键字

    继承可以运用 extends 和 implements
这片只主要字来贯彻连续,而且具有的切近都是继承给
java.lang.Object,当一个类没有持续的简单单根本字,则默认继承object(这个类似在 java.lang 包中,所以未待 import)祖先类。

extends关键字

   
在Java中,类的继续是纯粹继承,也就是说,一个子类只能拥有一个父类,所以
extends 只能继续一个类。

implements关键字

    使用 implements
关键字可以变相的使java具有多累的特色,使用限制也接近继承接口的事态,可以同时继续多独接口(接口和接口之间以逗号分隔)。

super 与 this 关键字

   
super关键字:我们可以经过super关键字来兑现对父类成员的看,用来引用当前目标的父类。

    this关键字:指向自己的援

final关键字

    final
关键字声明类可以拿看似定义也无克延续的,即最终类;或者用于修饰方法,该方式无能够被类更写:

声明类:
    final class 类名 {//类体}
声明方法:
    修饰符(public,private,void,protected等) final 返回值类型 方法名(){//方法体}

实例变量也可以于定义也final,被定义也final的变量不可知被改。被声称也final的外之方法自动地声称也final,但是实例变量并无是final。

 

构造器

   
子类不可知继续父类的构造器(构造方法或者构造函数),但是父类的构造器带有参数的,则须于子类的构造器中显式地由此super关键字调用父类的构造器并配以适宜的当属列表。

   
如果父类有管参构造器,则在子类的构造器中因故super调用父类构造器不是必的,如果没运用super关键字,系统会活动调用父类的不论是参构造器。

 

C++ 13C++ 14

class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("Hello everyone, my cardid is "+ id + ", and my name is " + name + "."); 
    } 
}


class Bird extends Animal { 
    public Bird(String myName, int myid) { 
        super(myName, myid); 
    } 
}

class Dog extends Animal { 
    public Dog(String myName, int myid) { 
        super(myName, myid); 
    } 
}


class SuperClass {
      private int n;
      SuperClass(){
        System.out.println("SuperClass()");
      }
      SuperClass(int n) {
        System.out.println("SuperClass(int n)");
        this.n = n;
        System.out.println("SuperClass(int n):"+this.n);
      }
}

class SubClass extends SuperClass{
      private int n;
      SubClass(){
        super(300);
        System.out.println("SuperClass");
      }
      public SubClass(int n){
        super(500);
        System.out.println("SubClass(int n):"+n);
        this.n = n;
        System.out.println("n:"+n+", this.n:"+this.n);
      }
}    

public class AnimalMain {
    public static void main(String[] args){
        Animal Mouseobjone = new Dog("小虎", 9);
        Mouseobjone.eat();    //小虎正在吃
        Mouseobjone.introduction();    //Hello everyone, my cardid is 9, and my name is 小虎.
        Animal Mouseobjtwo = new Dog("贝贝", 5);
        Mouseobjtwo.eat();    //贝贝正在吃
        Mouseobjtwo.introduction();    //Hello everyone, my cardid is 5, and my name is 贝贝.


        SubClass sc = new SubClass();
        //输出
        //SuperClass(int n)
        //SuperClass(int n):300
        //SuperClass
        SubClass sc2 = new SubClass(200);
        //输出
        //SuperClass(int n):500
        //SubClass(int n):200
        //n:200, this.n:200
    }
}

practice

 

四、重写(Override)与重载(Overload)

办法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的同等种表现,重载是平近乎吃多态性的平栽表现。

重写规则:

  • 参数列表必须完全同给重复写方法的均等;
  • 返回路必须完全同为还写方法的回来路相同;
  • 拜权限不克比较父类中为重复写的办法的走访权限重新不比。例如:如果父类的一个办法给声称也public,那么以子类中另行写该办法就未能够宣称也protected。
  • 父类的分子方法只有会吃她的子类重写。
  • 声明也final的道无克给重写。
  • 宣称也static的措施无能够叫还写,但是能够吃再度宣示。
  • 子类和父类在和一个包中,那么子类可以再写父类所有方,除了声明也private和final的办法。
  • 子类和父类不以和一个包中,那么子类只能够又写父类的声明也public和protected的非final方法。
  • 重写的道能够抛出任何不强制异常,无论给再写的计是否抛出异常。但是,重写的艺术不能够丢弃来新的强制性异常,或者比较为再次写方法声明的重复广的强制性异常,反的则可。
  • 构造方法不克给重写。
  • 只要非可知继承一个智,则未能够重写这法子。
  • 当得在子类中调用父类的于重新写方法时,要下super关键字。

C++ 15C++ 16

class Animal{
    public void move(){
        System.out.println("动物可以行走");
    }
}

class Dog extends Animal{
    public void move(){
        super.move();
        System.out.println("狗会跳");
    }
    public void bark(){
        System.out.println("狗会叫");
    }
}


public class Override {
    public static void main(String args[]){
        Animal animalobj = new Animal();
        Dog dogobj = new Dog();

        animalobj.move();
        dogobj.move();
        //dogobj.bark();    //会报错!!!抛出一个编译错误,因为dogobj的引用类型Animal没有bark方法。
    }
}

practice

 

重载(overloading)

大凡以一个像样里,方法名字同样,而参数不同。返回路可以同呢得以不同。

每个重载的艺术(或者构造函数)都必出一个无比的参数类型列表。

唯其如此重载构造函数

重载规则:

  • 吃重载的法子要反参数列表(参数个数或项目或者相继不雷同);
  • 受重载的主意好转移返回路;
  • 深受重载的章程可以转访问修饰符;
  • 叫重载的方可声明新的还是重广的自我批评大;
  • 主意能当和一个类中或者以一个子类中叫重载。
  • 无法因为回到值类型作为重载函数的区别标准。

C++ 17C++ 18

public class Overloading {
    public int test(){
        System.out.println("This is one.");
        return 1;
    }

    public void test(int a){
        System.out.println("This is two.");
    }

    public String test(int a,String s) {
        System.out.println("This is three.");
        return "3";
    }

    public static void main(String args[]) {
        Overloading olobj = new Overloading();
        System.out.println(olobj.test());    //This is one.、1
        olobj.test(1);    //This is two.
        System.out.println(olobj.test(1, "test3"));    //This is three.、3
    }
}

practice

 

五、多态

多态的长

    1. 排除类中的耦合关系
    1. 但替换性
    1. 可扩充性
    1. 接口性
    1. 灵活性
    1. 简化性

多态存在的老三个必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象

当以多态方式调用方法时,首先检查父类中是否来欠法,如果没有,则编译错误;如果来,再夺调用子类的同名方法。

多态的好处:可以使程序来美的恢弘,并可以针对所有类的目标进行通用处理

C++ 19C++ 20

public class Polymorphism {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dogo());  // 以 Dogo 对象调用 show 方法

        Animalo a = new Cat();  // 向上找方法  
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下找方法  
        c.work();        // 调用的是 Cat 的 catchMouse
    }

    public static void show(Animalo a)  {
        a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dogo) { // 狗做的事情 
            Dogo c = (Dogo)a;  
            c.work();  
        }  
    } 
}


abstract class Animalo {  
    abstract void eat();  
}  

class Cat extends Animalo {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dogo extends Animalo {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

practice

 

六、抽象类

要你想设计这样一个好像,该类包含一个特别的积极分子方法,该措施的实际实现由它的子类确定,那么你得于父类中声称该方法呢架空方法。

Abstract关键字同样可用来声称抽象方法,抽象方法就包含一个措施名,而从未方法体。

虚幻方法没有定义,方法名后一直与一个分行,而未是花括号。

声称抽象方法会导致以下简单单结果:

  • 假定一个好像富含抽象方法,那么该类必须是抽象类。
  • 旁子类必须另行写父类的空洞方法,或者声明自己也抽象类。

连续抽象方法的子类必须还写该方式。否则,该子类为得声明也抽象类。最终,必须有子类实现该抽象方法,否则,从早期的父类到终极之子类都不克因此来实例化对象。

空泛类规定1. 泛类非克于实例化(初家很容易犯之掠),如果为实例化,就见面报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。

    1. 泛类吃不自然带有抽象方法,但是有抽象方法的接近必定是抽象类。
  • 3.
    浮泛类吃的虚幻方法只有是宣称,不带有方法体,就是匪受有办法的具体贯彻为尽管是方法的有血有肉成效。

    1. 构造方法,类方式(用static修饰的法子)不克宣称也架空方法。
  • 5.
    抽象类的子类必须叫出抽象类中之抽象方法的切实落实,除非该子类为是抽象类。

C++ 21C++ 22

abstract class Employeem {
    private String name;
    private String address;
    private int number;

    public abstract double macPany();
}


class Salary extends Employeem{
    private double salary=1;
    public double macPany(){
        System.out.println("Welcome to macPany.");
        return salary;
    }
}


public class Employee {    
    public static void main(String[] args){
        Salary macPanyobj = new Salary();
        macPanyobj.macPany();
    }
}

practice

 

七、封装

当面向对象程式设计方法中,封装(Encapsulation)是指,一种植将抽象性函式接口的实作细节部份包装、隐藏起来的措施。

打包好让认为是一个保障屏障,防止此类的代码和数据给标类定义的代码随机访问。

只要拜访该类的代码和数码,必须经严的接口控制。

卷入最重点的效力在我们会改改好的贯彻代码,而无用修改那些调用我们代码的主次片段。

适度的包装好叫程式码更爱掌握以及维护,也增长了程式码的安全性。

包的优点

    1. 大好的包裹能够减少耦合。
    1. 恍如中的布局得以任意修改。
    1. 得对成员变量进行双重准的主宰。
    1. 隐形信息,实现细节,一般限制为private。

C++ 23C++ 24

public class EncapBase {
    public static void main(String[] args){
        EncapTmp encaptmpobj = new EncapTmp();
        System.out.println(encaptmpobj.getName());    //null
        encaptmpobj.setName("nick");
        System.out.println(encaptmpobj.getName());    //nick
    }
}


class EncapTmp{

    private String name;
    private int age;

    public String getName(){
        return name;
    }

    public int getAge(){
        return this.age;
    }

    public void setName(String namenew){
        name = namenew;
    }

    public void setAge(int age){
        this.age = age;
    }
}

practice

 

八、接口

接口(Interface),在JAVA编程语言中是一个空洞类型,是空洞方法的聚众,接口通常为interface来声称。一个接近经过连续接口的艺术,从而来延续接口的肤浅方法。

接口并无是相近,编写接口的法子与类似非常一般,但是它属于不同之概念。类描述对象的性能和办法。接口则含有类设实现的章程。

只有兑现接口的近乎是抽象类,否则该类要定义接口中之持有办法。

接口无法给实例化,但是好给实现。一个实现接口的接近,必须实现接口内所讲述的保有方,否则即必声明也抽象类。另外,在
Java
中,接口类型可用来声称一个变量,他们可变成一个空指针,或是被绑定在一个以此接口实现之对象。

接口和类似相似点:

  • 一个接口可以来差不多只点子。
  • 接口文件保留于 .java 结尾的公文被,文件称用接口名。
  • 接口的配节码文件保留在 .class 结尾的公文中。
  • 接口相应的配节码文件要于同保号相兼容的目结构被。

接口和类似的界别:

  • 接口不克用来实例化对象。
  • 接口没有构造方法。
  • 接口中有着的计要是纸上谈兵方法C++。
  • 接口不可知包含成员变量,除了 static 和 final 变量。
  • 接口不是被接近继承了,而是一旦受类似实现。
  • 接口支持多重新继承。

接口特性

  • 接口中列一个艺术为是隐式抽象的,接口中的道会吃隐式的指定为 public
    abstract
    (只能是 public abstract,其他修饰符都见面报错)。
  • 接口中可涵盖变量,但是接口中的变量会为隐式的指定为 public static
    final
     变量(并且不得不是 public,用 private 修饰会报编译错误。
  • 接口中之法门是未能够在接口中实现的,只能出于实现接口的近乎来落实接口中的法。
  • 接口是隐式抽象的,当声明一个接口的时节,不必采取abstract关键字。
  • 接口中列一个智吧是隐式抽象的,声明时一致未需要abstract关键子。
  • 接口中之方法都是公有的。

抽象类和接口的别

  • 架空类吃的点子可以来方法体,就是能兑现方式的有血有肉成效,但是接口中的法门好。
  • 虚幻类吃的分子变量可以是各种类型的,而接口中的成员变量只能是 public
    static final
     类型的。
  • 接口中不可知还有静态代码块和静态方法(用 static
    修饰的不二法门),而抽象类是好出静态代码块和静态方法。
  • 一个近似只能继续一个抽象类,而一个近乎可得以兑现多独接口。

接口的宣示语法格式如下:

[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}

接口的兑现

当类实现接口的下,类设促成接口中有所的计。否则,类必须声明也架空的近乎。

看似以implements关键字贯彻接口。在近似声明遭,Implements关键字在class声明后面。

贯彻一个接口的语法,可以动用此公式:

...class...implements 接口名称[, 其他接口, 其他接口..., ...] ...

 

C++ 25C++ 26

// Animal.java
interface Animal {
    public void eat();
    public void travel();
}

// Dog.java
public interface Dog extends Animal {
    public void FallInLove();
    public void HomePolice();
}

// Pig.java
public interface Pig {
    public void BigEat();
    public void Sleep();
}

// Sheep.java
public interface Sheep extends Animal, Pig {

}

单继承以及多累

C++ 27C++ 28

// Animal.java
interface Animal {
    public void eat();
    public void travel();
}

// MammalInt.java
public class MammalInt implements Animal {

    public void eat(){
        System.out.println("Animal eat..");
    }

    public void travel(){
        System.out.println("Animal travel..");
    }

    public static void main(String args[]){
        MammalInt mobj = new MammalInt();
        mobj.eat();    //Animal eat..
        mobj.travel();    //Animal travel..
    }

}

practice

 

九、包(package)

为重新好地组织类,Java 提供了确保机制,用于区分类名的命名空间。

管之企图

  • 1、把效益相似或有关的近乎还是接口组织以与一个包中,方便类的摸和利用。

  • 2、如同文件夹一样,包也使了树形目录的贮存方。同一个包中的类名字是不同之,不同之包中的切近的名是得一如既往的,当以调用两单不等包中相同类名的好像时,应该长包名加以区分。因此,包可免名字冲突。

  • 3、包也克了看权限,拥有包访问权限的接近才会访问有包中的类。

Java
使用包(package)这种体制是以以防万一命名冲突,访问控制,提供查找和定位类(class)、接口、枚举(enumerations)和注释(annotation)等。

package pkg1[.pkg2[.pkg3…]];

例如,一个Something.java 文件它的内容:
package net.java.util
public class Something{
   ...
}
# 它的路径应该是 net/java/util/Something.java 这样保存的

包申明

担保声明应该在来源文件之率先推行,每个来自文件只能发出一个保声明,这个文件中之每个品种且采用叫它。

如若一个起源文件被并未利用包声明,那么中的近乎,函数,枚举,注释等以于在一个榜上无名之包(unnamed
package)中。

包导入

payroll 包名
Employee 类名

payroll.Employee    # 全名导入
import payroll.*;    
import payroll.Employee;