Java初级笔记No.3（更新中）

2018.7.26

1、Java中的继承

Java中使用extends关键字来说明继承关系。

class Animals {
}

class Dogs extends Animals {
}

2、继承的特性

java中继承的特性与C++基本一致：
· 子类拥有父类中非private的属性，方法；
· 子类可以拥有自己的属性和方法；
· 子类可以用自己的方式实现父类的方法（即重写）；
· java中的继承是单继承，但是可以多重继承，单一般不使用多重继承，而采用接口的方式来实现多重继承。？？？这也是与C++中继承问题的不同。

3、继承相关关键字

extends
Java中使用extends关键字来说明单继承（一个子类只能拥有一个父类）：

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements
使用implements关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口和接口之间采用逗号分隔）：

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this
super关键字：用来实现对父类成员的访问，用来引用当前对象的父类，这在C++中是不允许的。

this关键字：类似于C++中的this指针，只不过java中没有指针的概念，这里是引用。

class Animal {
    void eat() {
        System.out.println("animal:eat");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("dog:eat");
    }
    void eatTest() {
        this.eat();
        super.eat();
    }
}

public class testFile {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        
        Dog d = new Dog();
        d.eatTest();
    }
}

这里父类中的方法没有访问控制权限标识，默认为default，下图说明了各个访问控制标识的访问范围（default也是与C++的区别）:

final

final关键字声明类可以把类定义为不能被继承的类，又叫做最终类。

final关键字还可以用于单独修饰方法，是的该方法不能被子类重写：


final class Base {  }  

public/private/default/protected final 返回值 method() {  }

另外，实例变量也可以被定义为final，被定义为final的变量不能被修改。被声明为final类的方法自动被声明为final，但实例变量并不是final。

4、构造函数

这里与C++中的构造函数基本一致，存在一个不同点是：

如果父类的构造函数中带有参数，则必须在子类的构造函数中显式的通过super关键字调用父类的构造函数，并配以适当的参数列表。

如果父类构造函数没有参数，则在子类的构造函数中不需要使用super关键字调用父类的构造函数，系统会自动调用父类的无参数构造函数：

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

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

public class TestSuperSub {
    public static void main(String[] args) {
        SubClass sc = new SubClass();   //SuperClass(int n), SubClass()
        System.out.println();
        SubClass sc2 = new SubClass(200);   //SuperClass(), SubClass(int n)
    }
}

5、Override与Overload

Override->重写，Overload->重载，这里从概念上将于C++没什么区别。

Override

当需要在子类中调用父类的被重写的方法时，需要使用super关键字：

class Animal{
       public void move(){
          System.out.println("动物可以移动");
       }
    }
     
class Dog extends Animal{
   public void move(){
      super.move();  //调用Animal的move
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}
     
public class testFile{
   public static void main(String args[]){
      Animal b = new Dog();
      b.move();//执行Dog，但是由于其中调用了super，所以也会输出Animal中的内容
   }
}

Overload

6、 Java中的多态

同C++相同，java中多态的存在需要三个必要条件：
· 继承； · 重写； ·父类引用指向子类对象呢。

7、抽象类
如果一个类中没有包含足够的信息来描绘一个具体的对象呢，这个类就是抽象类 ，其与C++中抽象类的概念一致，不能用于实例化对象，主要用于接口的指定。

C++中使用纯虚函数来表示抽象类，java中使用关键字abstract来声明一个抽象类：

public abstract class Base {  }

8、抽象方法
一个类中包含一些特别的成员方法，该方法的具体实现由其子类确定，则可以在父类中声明该方法为抽象方法：

抽象方法只包含一个方法名，没有方法体。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其余代码
}

声明抽象方法会造成一下两个结果：
· 如果一个类中包含抽象方法，则该类必须是抽象类；
· 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

9、Java中的封装
这与C++中的封装没有什么区别，主要以private体现。

10、Java中的接口

在Java中抽象方法的集合通常以interface来声明，称之为接口，这与golang中的接口一致。

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

接口使用实例：

/*AnimalH.java*/
package test2;

interface AnimalH {
    public void eat();
    public void travel();
}

类使用implements关键字实现接口。

package test2;

public class MammalInt implements AnimalH {
    public void eat() {
        System.out.println("Mammal eats");
    }
    
    public void travel() {
        System.out.println("Mammal travels");
    }
    
    public int noOfLegs() {
        return 0;
    }  
    
    public static void main(String[] args) {
        MammalInt m = new MammalInt();
        m.eat();
        m.travel();
    }
}

11、同时，接口与接口之间也可以由继承关系，用extends关键字表示：

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

12、接口的多继承
在java中，类的多继承是不合法的，但接口允许多继承。
在接口的多继承中，extands关键字只需要使用一次，在后面跟着继承接口：

public interface Hockey extends Sports, Event  {}

一个类可以实现多个接口，使用implements关键字，后面跟实现的接口：

public class People implements Sports, Event {}

13、没有任何方法的接口被称为标记接口：

其作用为：

13、Java中的包，是C++中没有的概念。包的存在是为了更好的组织类，用于区别类名的命名空间。

import
为了使用某个包中的成员，需要在java程序中明确导入该包，使用import关键字来完成对包的导入。

本文来自：简书

感谢作者：wenmingxing

查看原文：Java初级笔记No.3（更新中）

2018.7.26

用户登录

今日阅读排行

一周阅读排行

2018.7.26