前言
C语言是面向过程,而java是面向对象,这两者在思想上有一些不同
继承
- 继承格式:使用extends
class 父类 {
}
class 子类 extends 父类 {
}
- 作用:两个类有共同的属性和方法,可以把共同的属性和方法提取到一个类,然后进行构造父类
- 继承的种类
单继承:class B->class A
多重继承:class C-->class B-->class C
共同继承一个类的:class B-->class A<--class C
不支持多继承:class B,C-->class A
- 特点
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
- extends关键词,是单一继承,就是一个子类只能继承一个父类
- implements关键词,相当于多重继承,就是与接口相结合:interface,继承多个接口
在这里插入代码片
7.关键词:
7. super关键词:可以实现对父类成员的访问(方法和属性)
8. this关键词:对象的调用,对象自己的方法的调用
9. final关键词:被final修饰的类,不能被继承,被final修饰的方法不能被重写
重写和重载
- 重写
对父类的方法进行重新定义方法
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
1.被final,private修饰的,不能别重写
2.static修饰的,不能被重写,但是可以被再次声明
3.构造方法不能被重写
- 重载
参数类型,返回类型,参数个数都可以改变,方法名名字相同
- 被重载的方法必须改变参数列表(参数个数或类型不一样);
- 被重载的方法可以改变返回类型;
- 被重载的方法可以改变访问修饰符;
- 被重载的方法可以声明新的或更广的检查异常;
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
多态
- 重写或者重载(上面有)
- 定义对象时,父类和子类:
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
抽象类
- 抽象类由 abstract class来定义抽象类,抽象类不能实例化对象(定义对象),但是可以被继承,子类拥有抽象类的成员属性和成员方法。
- 代码演示:
父类
package java学习练习案例;
public abstract class Employee {
private String name;
private String address;
private int number;
public Employee(String initialName,String initialAddress,int initialNumber) {
name = initialName;
address=initialAddress;
number=initialNumber;
}
public double computePay()
{
System.out.println("Inside Employee computePay");
return 0.0;
}
public void mailCheck()
{
System.out.println("Mailing a check to " + this.name
+ " " + this.address);
}
public String toString(){
return "名字是:"+name+"地址是:"+address+"数量是:"+number;
}
//封装类
public String getName(){
return name;
}
public String getAddress(){
return address;
}
public int getNumber(){
return number;
}
public void setName(String newName){
name=newName;
}
public void setAddress(String newAddress){
address=newAddress;
}
public void setNumber(int newNumber){
number=newNumber;
}
}
子类
/* 文件名 : Salary.java */
public class Salary extends Employee
{
private double salary; //Annual salary
public Salary(String name, String address, int number, double
salary)
{
super(name, address, number);
setSalary(salary);
}
public void mailCheck()
{
System.out.println("Within mailCheck of Salary class ");
System.out.println("Mailing check to " + getName()
+ " with salary " + salary);
}
public double getSalary()
{
return salary;
}
public void setSalary(double newSalary)
{
if(newSalary >= 0.0)
{
salary = newSalary;
}
}
public double computePay()
{
System.out.println("Computing salary pay for " + getName());
return salary/52;
}
}
测试类:
/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
public static void main(String [] args)
{
Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
System.out.println("Call mailCheck using Salary reference --");
s.mailCheck();
System.out.println("\n Call mailCheck using Employee reference--");
e.mailCheck();
}
}
- 抽象方法:
父类的抽象方法,只有方法头,没有方法体,方法体由子类来进行重写
一个类包含抽象方法,这个类一定是抽象类
子类一定重写抽象方法。
- 一些规定:
1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。
2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
4. 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。
5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。
封装:
- 成员属性的封装:使用private封装
- 使用get或者set方法,对成员属性进行获得和修改
- 成员方法使用public
/* 文件名: EncapTest.java */
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
接口
- 接口的声明:
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
声明变量只能为被final,static修饰的变量。
声明接口和方法时,都不需要abstract关键字来修饰。
接口的方法是公有的。
实例
interface Animal {
public void eat();
public void travel();
public class MammalInt implements Animal{
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();
}
}
}
- 一些规则:
重写接口中声明的方法时,需要注意以下规则:
类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。
类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。
如果实现接口的类是抽象类,那么就没必要实现该接口的方法。
在实现接口的时候,也要注意一些规则:
一个类可以同时实现多个接口。
一个类只能继承一个类,但是能实现多个接口。
一个接口能继承另一个接口,这和类之间的继承比较相似。(可以多继承,多重继承)