目录
java中使用类对现实世界中实体进行描述,类经过实例化之后的产物对象,则可以用来表示现实中的实体。但是现实世界一些事物可能存在关联,在设计程序时就需要考虑。
比如:猫和狗都是动物。
创建一个狗类:
- //狗类
- public class Dog {
- String name;
- int age;
- float weight;
- public void eat(){
- System.out.println(name+"正在吃饭");
- }
- public void sleep(){
- System.out.println(name+"正在睡觉");
- }
- public void Bark(){
- System.out.println(name+"汪汪汪");
- }
- }
创建一个猫类
- public class Cat {
- String name;
- int age;
- float weight;
- public void eat(){
- System.out.println(name+"正在吃饭");
- }
- public void sleep(){
- System.out.println(name+"正在睡觉");
- }
- public void mew(){
- System.out.println(name+"喵喵喵");
- }
- }
我们会发现上述创建的狗类和猫类有很多相同的地方:它们都有名字,年龄,都会吃饭睡觉等等。我们能否将这些共性给抽取出来,实现代码的复用呢?
允许程序员在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称子类(派生类)。
狗和猫都是动物,我们就可以将共性的内容进行抽取,然后用继承的思想来达到共用。
在Java中如果要表示类之间的继承关系,需要借助extends关键字
写一个Animal类作为父类:
- public class Animal {
- String name;
- int age;
- float weight;
- public void eat(){
- System.out.println(name+"正在吃饭");
- }
- public void sleep(){
- System.out.println(name+"正在睡觉");
- }
- }
重写狗类:
- public class Dog extends Animal {
- public void Bark(){
- System.out.println(name+"汪汪汪");
- }
- }
重写猫类:
- public class Cat extends Animal {
- public void mew(){
- System.out.println(name+"喵喵喵");
- }
- }
可以发现我们重新写的狗类和猫类节省了大量的代码。
注意:
1. 子类会将父类中的成员变量或者成员方法继承到子类中
2. 子类继承父类之后,必须要新添加自己特有的成员,体现出与父类的不同,否则就没有必要继承了
- public class Base {
- int a;
- int b;
- }
- public class Derived extends Base{
- int c;
- public void method(){
- a = 10;
- // 访问从父类中继承下来的a
- b = 20; // 访问从父类中继承下来的b
- c = 30; // 访问子类自己的c
- }
- }
2. 子类和父类成员变量同名
- public class Base {
- int a;
- int b;
- int c;
- }
- public class Derived extends Base {
- int a; // 与父类中成员a同名,且类型相同
- char b; // 与父类中成员b同名,但类型不同
-
- public void method() {
- a = 100; // 就近,访问子类自己的a
- b = 101; // 就近原则访问子类自己的b
- c = 102; // 子类没有c,访问的肯定是从父类继承下来的c
- d = 103; // 编译失败,因为父类和子类都没有定义成员变量b
- }
- }
- public class Base {
- public void methodA(){
- System.out.println("Base中的methodA()");
- }
- public void methodB(){
- System.out.println("Base中的methodB()");
- }
- }
- public class Derived extends Base{
- public void methodA(int a) {
- System.out.println("Derived中的method(int)方法");
- }
- public void methodB(){
- System.out.println("Derived中的methodB()方法");
- }
- public void methodC(){
- methodA(); // 没有传参,访问父类中的methodA()
- methodA(20); // 传递int参数,访问子类中的methodA(int)
- methodB(); // 直接访问,则永远访问到的都是子类中的methodB(),父类的无法访问到
- }
- }
- public class Base {
- int a;
- int b;
- public void methodA(){
- System.out.println("Base中的methodA()");
- }
- public void methodB(){
- System.out.println("Base中的methodB()");
- }
- }
- public class Derived extends Base {
- int a;
- // 与父类中成员变量同名且类型相同
- char b; // 与父类中成员变量同名但类型不同
-
- // 与父类中methodA()构成重载
- public void methodA(int a) {
- System.out.println("Derived中的method()方法");
- }
- // 与基类中methodB()构成重写
-
- public void methodB() {
- System.out.println("Derived中的methodB()方法");
- }
-
- public void methodC() { // 对于同名的成员变量,直接访问时,访问的都是子类的
- a = 100; // 等价于: this.a = 100;
- b = 101; // 等价于: this.b = 101;
- // 注意:this是当前对象的引用 // 访问父类的成员变量时,需要借助super关键字
- // super是获取到子类对象中从基类继承下来的部分
- super.a = 200;
- super.b = 201;
- // 父类和子类中构成重载的方法,直接可以通过参数列表区分清访问父类还是子类方法
- methodA(); // 没有传参,访问父类中的methodA()
- methodA(20); // 传递int参数,访问子类中的methodA(int) // 如果在子类中要访问重写的基类方法,则需要借助super关键字
- methodB(); // 直接访问,则永远访问到的都是子类中的methodA(),基类的无法访问到
- super.methodB(); // 访问父类的methodB()
- }
- }
- public class Base {
- public Base(){
- System.out.println("Base()");
- }
- }
子类
- public class Derived extends Base{
- public Derived() {
- // super();
- // 注意子类构造方法中默认会调用基类的无参构造方法:super(),
- // 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句,
- // 并且只能出现一次
- System.out.println("Derived()");
- }
- }
运行结果:
- public class Test {
- public static void main(String[] args) {
- Derived d = new Derived();
- }
- }
先调用了public Base,后调用了Derived
子类对象中成员是有两部分组成的,父类继承下来的以及子类新增加的部分 。
代码执行顺序:
- class Person {
- public String name;
- public int age;
- public Person(String name, int age) {
- this.name = name;
- this.age = age;
- System.out.println("构造方法执行");
- }
- {
- System.out.println("实例代码块执行");
- }
- static {
- System.out.println("静态代码块执行");
- }
- }
- public class TestDemo {
- public static void main(String[] args) {
- Person person1 = new Person("zhangsan",10);
- System.out.println("============================");
- Person person2 = new Person("lisi",20);
- }
- }
- class Student extends Person{
- public Student(String name,int age) {
- super(name,age);
- System.out.println("Student:构造方法执行");
- }
- {
- System.out.println("Student:实例代码块执行");
- }
- static {
- System.out.println("Student:静态代码块执行");
- }
- }
- public class TestDemo2 {
- public static void main(String[] args) {
- Student student1 = new Student("张三", 19);
- System.out.println("===========================");
- Student student2 = new Student("李四", 20);
- }
- }
执行结果:
父类中不同访问权限的成员,在子类中的可见性又是什么样子的呢?
extend01包中
- // extend01包中
- public class B {
- private int a;
- protected int b;
- public int c;
- int d;
- }
extend01包中的子类:
- public class D extends B{
- public void method(){
- super.a = 10; // 编译报错,父类private成员在相同包子类中不可见
- super.b = 20;// 父类中protected成员在相同包子类中可以直接访问
- super.c = 30; // 父类中public成员在相同包子类中可以直接访问
- super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
- }
- }
extend02包中的子类:
- public class C extends B {
- public void method(){
- super.a = 10; // 编译报错,父类中private成员在不同包子类中不可见
- super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
- super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
- super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
- }
- }
extend02中的非子类
- public class Test {
- public static void main(String[] args) {
- C c = new C();
- c.c = 10;// 父类中public成员在不同包其他类中可以直接访问
- c.d = 20;// 报错:父类中protected成员在不同包其他类中不能直接访问
- }
注意:父类中private成员变量虽然在子类中不能直接访问,但是也继承到子类中了
- final int a = 10;
- a = 20; // 编译出错
- final public class Animal {
- ...
- }
- public class Bird extends Animal {
- ...
- }// 编译出错
- // 轮胎类
- class Tire{
- // ...
- }
- // 发动机类
- class Engine{
- // ...
- }
- // 车载系统类
- class VehicleSystem{
- // ...
- }
- class Car{
- private Tire tire; // 可以复用轮胎中的属性和方法
- private Engine engine; // 可以复用发动机中的属性和方法
- private VehicleSystem vs; // 可以复用车载系统中的属性和方法
- // ...
- }
- // 奔驰是汽车
- class Benz extend Car{
- // 将汽车中包含的:轮胎、发送机、车载系统全部继承下来
- }