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

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传