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关键字来完成对包的导入。
网友评论