一篇文章搞懂包、继承、方法重写

文章目录

• 一、包
• • 1、导入包中的类
  • 2、静态导入
  • 3、包的访问权限控制
• 二、继承
• • • 1、背景
  • 2、语法规则
  • 3、protected关键字
  • 4、final关键字
  • 5、小结: Java 中对于字段和方法共有四种访问权限
  • 三、方法重写
  • • 1、背景
    • 2、语法规则

一、包

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性.

例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过.

而不同包下面的类是可以重名的，不会发生冲突。

如果我们需要使用另一个包下面的类怎么办呢？
此时我们就需要导包

1、导入包中的类

可以使用 impor.包名.类名 这种方式引入 这个包中的这个类.

注意;

导入的只是这个包里面的某一个类，不是整个包，不是这个包里面的所有类。

一次只能导入某一个包中的某一个类，当已经导入一个类后，还想要再导入另一个类，就需要用全名称访问。

2、静态导入

使用 import static 可以导入包中的静态的方法和字段

注意：
静态字段必须使用public修饰，否则无法导入。

使用这种方式可以更方便的写一些代码, 例如：

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些. 
        // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
   }
}

3、包的访问权限控制

我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.
下面的代码给了一个示例. Demo1 和 Demo2 是同一个包中, Test 是其他包中.

Demo1.java

package com.bit.demo;
public class Demo1 {
    int value = 0;
}

Demo2.java

package com.bit.demo; 
public class Demo2 { 
 public static void Main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 执行结果, 能够访问到 value 变量
10 

Test.java

import com.bit.demo.Demo1; 
public class Test { 
 public static void main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 编译出错
Error:(6, 32) java: value在com.bit.demo.Demo1中不是公共的; 无法从外部程序包中对其进行访问

二、继承 1、背景

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.
例如, 设计一个类表示动物

注意, 我们可以给每个类创建一个单独的 java 文件. 类名必须和 .java 文件名匹配(大小写敏感).

// Animal.java 
public class Animal { 
 public String name; 
 
 public Animal(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Cat.java 
class Cat { 
 public String name; 
 
 public Cat(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
class Bird { 
 public String name; 
 
 public Bird(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); 
 } 
}

我们发现上面的很多代码是重复的，很多的代码是冗余的
经过我们分析，这三个类存在一种 is a的关系Bird is a Animal，Cat is a Animal；
并且：

这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
这三个类都具备一个相同的 name 属性, 而且意义是完全一样的

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.
此时, Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类, 对于像 Cat 和 Bird 这样的类, 我们称为 子类, 派生类和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果。

2、语法规则

class 子类 extends 父类{
}

对于上面的代码, 可以使用继承进行改进. 此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法.

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 调用父类的构造方法. 
        super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
} 

注意：
1、继承只能单继承，但是可以多层继承。

就相当于在一个家庭里面，一个孩子只会有一个亲生父亲，这就叫单继承。
但是他还有爷爷，父亲继承了爷爷，孩子继承了父亲，这就叫多继承。

2、继承会继承父类的全部的属性和public修饰的方法但是有显示的和隐示的。

例如：父类的某一个属性使用了private修饰了，但是如果提供了get/set方法，子类还是能对这个属性进行访问。

3、protected关键字

protected关键字修饰的属性和方法只能子类或者同一个包里面的类访问。

4、final关键字

前面我们讲过 final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改).

final int a = 10; 
a = 20; // 编译出错

这里,final关键字也可以修饰类，final修饰的类和被final修饰的属性一样，是最终的，是不可被继承的。

5、小结: Java 中对于字段和方法共有四种访问权限

private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
public : 类内部和类的调用者都能访问

思考小问题:
当我们子类某个方法和父类的不同，但是我们知道，子类继承了父类的方法，此时我们应该怎么办呢？

三、方法重写 1、背景

下面是一个Dog类

public class Dog {
   public void eat() {
      System.out.println("吃狗粮");
   }
}

然后我们又定义了一个泰迪类，这两个类满足，泰迪 is a Dog；这时我们让泰迪类去继承Dog类

public class teddy extends Dog{

}

但是问题来了
父类中有个eat方法，表示狗吃东西，泰迪类继承了Dog类，那么泰迪类继承了Dog中的eat方法，但是这只泰迪很怪，他只吃肉，这时怎么办呢？？
我们就可以将父类中的eat方法在子类中进行重写。

2、语法规则

方法重写与方法重载不同，方法重写要求：方法名，返回值类型，形参列表都要相同，特殊情况下返回值类型可以不同。
例如上面的问题此时我们就可以使用方法重写解决

public class teddy extends Dog{
    @Override
    public void eat() {
        System.out.println("吃肉");
    }
 }

此时我们使用泰迪类的对象调用eat方法就会是重写后的方法。
注意事项：

1、父类中用private修饰的方法不能进行重写
2、重写后的方法权限要大于或者等于父类该方法的权限。