Java学习笔记Day8 面向对象（三）

最新推荐文章于 2025-12-17 19:02:04 发布

原创最新推荐文章于 2025-12-17 19:02:04 发布 · 210 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #编程语言 #面向对象编程

本文详细探讨了Java中的继承机制，如何使用'extends'关键字，以及super和this关键字在构造器和方法中的应用。重点讲解了方法重写的概念，包括重写条件和其背后的原因。

文章目录

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是扩展。子类是父类的扩展。

Java中类只有单继承，没有多继承

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有"is a"的关系

//在Java中，所有的类都默认直接或间接继承Object类
//Person 类 ：父类
public class Person /*extends Object*/ {
	//public protected default private

	private int money = 10_0000_0000;

	public void say(){
		System.out.println("说了一句话");
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) { 
		this.money = money;
	}
}

//学生 is 人 ： 子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {

	//ctrl+h 继承树
}

//Teacher is 人  ：子类
public class Teacher extends Person{
}

public class Application {
	public static void main(String[] args) {
		Student student = new Student();
		student.say(); //说了一句话
		//System.out.println(student.money); //私有无法继承
		student.setMoney(1000000000);
		System.out.println(student.getMoney());//1000000000
	}
}

super - this 关键字

public class Person /*extends Object*/ {

   public Person() { //构造器
      System.out.println("Person无参执行");
   }

   protected String name = "cehncehn";

   public void print(){
      System.out.println("Person");
   }
}

public class Student extends Person {

	public Student() {
		//隐藏代码；调用了父类的无参构造
		super();//调用父类的构造器，必须要在子类构造器的第一行
		System.out.println("Student无参执行");
	}

	private String name = "cc";

	public  void print(){
		System.out.println("Student");
	}

	public void test1(String name){
		System.out.println(name); //2c
		System.out.println(this.name); //cc
		System.out.println(super.name); //cehncehn
	}
	//私有的东西无法被super调用
	public void test2(){
		print(); //student
		this.print(); //student
		super.print(); //person
	}
}

public class Application {
	public static void main(String[] args) {

		Student student = new Student();//Person无参执行  Student无参执行
		student.test1("2c");
		student.test2();
	}
}

super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一个
    2.super必须只能出现在子类的方法或者构造方法中
    3.super和this不能同时调用构造方法

super 和 this
    代表的对象不同：
        1.this： 本身调用者这个对象
        2.super：代表父类对象的引用
    前提：
        1.this: 没有继承也可以使用
        2.super： 只能在继承条件下使用
    构造方法
        this():本类的构造
        super():父类的构造

方法重写

//重写都是方法的重写，与属性无关。
public class B {
	public void test(){
		System.out.println("B=>test()");
	}
}

public class A extends B{

	@Override//注解：有功能的注释 //重写
	public void test() {
		System.out.println("A=>test()");
	}
}

public class Application {
	//静态的方法和非静态的方法区别很大！！！
		//静态方法：方法的调用只和左边定义的数据类型有关
	//非静态：重写
	public static void main(String[] args) {

		A a = new A();
		a.test(); //A=>test()

		//父类的引用指向了子类
		B b = new A();//子类重写了父类的方法
		b.test(); //A=>test()
	}
}

重写：需要有继承关系，子类重写父类的方法
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大但不能缩小：public>protected>default>private
    4.抛出的异常：范围可以被缩小但不能扩大

重写：子类的方法和父类要一致，方法体不同。
为什么需要重写？
    1.父类的功能子类不一定需要或者不一定满足