java基础之面向对象（四）

.诗酒趁年华

已于 2022-03-21 17:39:17 修改

阅读量108

点赞数

分类专栏： java 文章标签： java 学习

于 2022-03-21 16:19:21 首次发布

本文链接：https://blog.csdn.net/weixin_50020236/article/details/123638613

版权

java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

本文介绍了Java中的面向对象特性，包括继承性、方法的重写、super关键字的使用、子类对象实例化的全过程以及多态性。详细讲解了继承的好处、格式以及Java的继承规定，重写的方法声明、应用及其规则，并探讨了super关键字在调用属性和构造器中的作用。最后，阐述了子类对象实例化的步骤和多态性的概念及使用场景。

摘要由CSDN通过智能技术生成

1、继承性

1、继承性的好处：
① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提

2、继承性的格式：
class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass

2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
    特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
子类和父类的关系，不同于子集和集合的关系。
extends：延展、扩展

3、Java中关于继承性的规定：
   1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

4、

1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
3. 意味着，所有的java类具有java.lang.Object类声明的功能。

例：

父类 Creature

public class Creature {
	
	public void breath(){
		System.out.println("呼吸");
	}
	
}

子类 Person

public class Person extends Creature{
	
	String name;
	private int age;
	
	public Person(){
		
	}
	
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void eat(){
		System.out.println("吃饭");
		sleep();
	}
	
	private void sleep(){
		System.out.println("睡觉");
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	
}

子类 Student

public class Student extends Person{
	
//	String name;
//	int age;
	String major;
	
	public Student(){
		
	}
	public Student(String name,int age,String major){
		this.name = name;
//		this.age = age;
		setAge(age);
		this.major = major;
	}
//	public void eat(){
//		System.out.println("吃饭");
//	}
//	
//	public void sleep(){
//		System.out.println("睡觉");
//	}
	
	public void study(){
		System.out.println("学习");
	}
	
	public void show(){
		System.out.println("name:" + name + ",age:" + getAge());
	}
	
}

测试：ExtendsTest

public class ExtendsTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
//		p1.age = 1;
		p1.eat();
		System.out.println("*****************");
		
		Student s1 = new Student();
		s1.eat();
//		s1.sleep();
		s1.name = "Tom";
		s1.setAge(10);
		System.out.println(s1.getAge());
		
		s1.breath();
		
		
		Creature c = new Creature();
		System.out.println(c.toString());
	}
}

2、方法的重写(override / overwrite)

1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

3. 重写的规定：
           方法的声明：权限修饰符返回值类型方法名(形参列表) throws 异常的类型{
                       //方法体
                   }
           约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
    >特殊情况：子类不能重写父类中声明为private权限的方法
③ 返回值类型：
    >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
    >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
    >父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
        ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
说明：
        子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。

例：

父类：Person

public class Person {
	
	String name;
	int age;
	
	public Person(){
		
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	 void eat(){
		System.out.println("吃饭");
	}
	public void walk(int distance){
		System.out.println("走路,走的距离是：" + distance + "公里");
		show();
		eat();
	}
	
	private void show(){
		System.out.println("我是一个人");
	}
	
	public Object info(){
		return null;
	}
	
	public double info1(){
		return 1.0;
	}

}

子类：Student

public class Student extends Person{

	String major;
	
	public Student(){
		
	}
	public Student(String major){
		this.major = major;
	}
	
	public void study(){
		System.out.println("学习。专业是：" + major);
	}
	
	//对父类中的eat()进行了重写
	public void eat(){
		System.out.println("学生应该多吃有营养的食物");
	}
	
	public void show(){
		System.out.println("我是一个学生");
	}
	
	public String info(){
		return null;
	}
	
//	public int info1(){
//		return 1;
//	}
	
//	public void walk(int distance){
//		System.out.println("重写的方法");
//	}
	
	
	public void walk(int distance) {
		System.out.println("重写的方法");
	}

}

测试

public class PersonTest {
	
	public static void main(String[] args) {
		
		Student s = new Student("计算机科学与技术");
		s.eat();
		s.walk(10);
		
		System.out.println("**************");
		
		s.study();
		
		Person p1 = new Person();
		p1.eat();
		
	}
}

3、super关键字的使用

1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器

3.super的使用：调用属性和方法

3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的
使用"super.方法"的方式，表明调用的是父类中被重写的方法。

4.super调用构造器
   4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

例：

父类：Person

public class Person {
	String name;
	int age;
	int id = 1001;//身份证号
	
	public Person(){
		System.out.println("我无处不在！");
	}
	
	public Person(String name){
		this.name = name;
	}
	
	public Person(String name,int age){
		this(name);
		this.age = age;
	}
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	public void walk(){
		System.out.println("人：走路");
	}
}

子类Student

public class Student extends Person{
	
	String major;
	int id = 1002;//学号
	
	public Student(){
		super();
	}
	public Student(String major){
		super();
		this.major = major;
	}
	
	public Student(String name,int age,String major){
//		this.name = name;
//		this.age = age;
		super(name,age);
		this.major = major;
	}
	
	@Override
	public void eat() {
		System.out.println("学生：多吃有营养的食物");
	}
	
	public void study(){
		System.out.println("学生：学习知识");
		this.eat();
		super.eat();
		walk();
	}
	
	public void show(){
		System.out.println("name = " + name + ", age = " + age);
		System.out.println("id = " + this.id);
		System.out.println("id = " + super.id);
	}
}

测试

public class SuperTest {
	public static void main(String[] args) {
		
		Student s = new Student();
		s.show();
		
		System.out.println();
		
		s.study();
		
		Student s1 = new Student("Tom", 21, "IT");
		s1.show();
		
		System.out.println("************");
		Student s2 = new Student();
		
	}
}

4、子类对象实例化的全过程

1. 从结果上来看：（继承性）
       子类继承父类以后，就获取了父类中声明的属性或方法。
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

2. 从过程上来看：
       当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，...
直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有
父类中的结构，子类对象才可以考虑进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

5、多态性

1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

3. 多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。

4.多态性的使用前提： ① 类的继承关系 ② 方法的重写

5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

例

父类：Person

public class Person {
	String name;
	int age;
	
	int id = 1001;
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	
	public void walk(){
		System.out.println("人：走路");
	}
	
}

子类：Man

public class Man extends Person{
	
	boolean isSmoking;
	
	int id = 1002;
	
	public void earnMoney(){
		System.out.println("男人负责挣钱养家");
	}
	
	public void eat(){
		System.out.println("男人多吃肉，长肌肉");
	}
	
	public void walk(){
		System.out.println("男人霸气的走路");
	}

}

子类：Woman

public class Woman extends Person{
	
	boolean isBeauty;
	
	public void goShopping(){
		System.out.println("女人喜欢购物");
	}
	
	public void eat(){
		System.out.println("女人少吃，为了减肥");
	}
	
	public void walk(){
		System.out.println("女人窈窕的走路");
	}
}

测试

public class PersonTest {
	
	
	public static void main(String[] args) {
		
		Person p1 = new Person();
		p1.eat();
		
		Man man = new Man();
		man.eat();
		man.age = 25;
		man.earnMoney();
		
		//*************************************************
		System.out.println("*******************");
		//对象的多态性：父类的引用指向子类的对象
		Person p2 = new Man();
//		Person p3 = new Woman();
		//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
		p2.eat();
		p2.walk();
		
//		p2.earnMoney();
		
		System.out.println(p2.id);//1001
		
	}
}

面试题：多态是编译时行为还是运行时行为？

import java.util.Random;

//面试题：多态是编译时行为还是运行时行为？
//证明如下：
class Animal  {
 
	protected void eat() {
		System.out.println("animal eat food");
	}
}

class Cat  extends Animal  {
 
	protected void eat() {
		System.out.println("cat eat fish");
	}
}

class Dog  extends Animal  {
 
	public void eat() {
		System.out.println("Dog eat bone");

	}

}

class Sheep  extends Animal  {
 

	public void eat() {
		System.out.println("Sheep eat grass");

	}

 
}

public class InterviewTest {

	public static Animal  getInstance(int key) {
		switch (key) {
		case 0:
			return new Cat ();
		case 1:
			return new Dog ();
		default:
			return new Sheep ();
		}

	}

	public static void main(String[] args) {
		int key = new Random().nextInt(3);

		System.out.println(key);

		Animal  animal = getInstance(key);
		
		animal.eat();
		 
	}

}

题2

父类：Account

public class Account {
	private int id;//账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public Account(int id, double balance, double annualInterestRate) {
		super();
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}

	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
	//返回月利率
	public double getMonthlyInterest(){	
		return annualInterestRate / 12;
	}
	//取钱
	public void withdraw (double amount){
		if(balance >= amount){
			balance -= amount;
			return;
		}
		System.out.println("余额不足");
	}
	//存钱
	public void deposit (double amount){
		if(amount > 0){
			balance += amount;
		}
	}


}

子类：CheckAccount

/*
 * 创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额。
 * 在CheckAccount类中重写withdraw方法，其算法如下：
 *		如果（取款金额<账户余额），
 *		可直接取款
 *		如果（取款金额>账户余额），
 *		计算需要透支的额度
 *		判断可透支额overdraft是否足够支付本次透支需要，如果可以
 *			将账户余额修改为0，冲减可透支金额
 *		如果不可以
 *			提示用户超过可透支额的限额
 *
 * 
 * 
 */
public class CheckAccount extends Account{
	
	private double overdraft;//可透支限额
	
	public CheckAccount(int id, double balance, double annualInterestRate,double overdraft){
		super(id, balance, annualInterestRate);
		this.overdraft = overdraft;
		
	}
	
	
	public double getOverdraft() {
		return overdraft;
	}


	public void setOverdraft(double overdraft) {
		this.overdraft = overdraft;
	}


	@Override
	public void withdraw(double amount) {
		if(getBalance() >= amount){//余额就足够消费
//			getBalance() -= amount;
			//方式一：
//			setBalance(getBalance() - amount); 
			//方式二：
			super.withdraw(amount);
		}else if(overdraft >= amount - getBalance()){//透支额度+余额足够消费
			
			overdraft -= (amount - getBalance());
			
//			setBalance(0);
			//或
			super.withdraw(getBalance());
			
		}else{
			System.out.println("超过可透支限额！");
		}
	}

}

测试

/*
   写一个用户程序测试CheckAccount类。
   在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。
	使用withdraw方法提款5000元，并打印账户余额和可透支额。
	再使用withdraw方法提款18000元，并打印账户余额和可透支额。
	再使用withdraw方法提款3000元，并打印账户余额和可透支额。

 * 
 */
public class CheckAccountTest {
	public static void main(String[] args) {
		
		CheckAccount acct = new CheckAccount(1122, 20000, 0.045, 5000);
		
		acct.withdraw(5000);
		System.out.println("您的账户余额为：" + acct.getBalance());
		System.out.println("您的可透支额度为：" + acct.getOverdraft());
		acct.withdraw(18000);
		System.out.println("您的账户余额为：" + acct.getBalance());
		System.out.println("您的可透支额度为：" + acct.getOverdraft());
		acct.withdraw(3000);
		System.out.println("您的账户余额为：" + acct.getBalance());
		System.out.println("您的可透支额度为：" + acct.getOverdraft());
		
		
	}
}

测试

/*
 * 写一个用户程序测试Account类。在用户程序中，
 * 创建一个账号为1122、余额为20000、年利率4.5%的Account对象。
 * 使用withdraw方法提款30000元，并打印余额。
 * 再使用withdraw方法提款2500元，
 * 使用deposit方法存款3000元，然后打印余额和月利率。

 * 
 */
public class AccountTest {
	public static void main(String[] args) {
		
		Account acct = new Account(1122, 20000, 0.045);
		
		acct.withdraw(30000);
		System.out.println("您的账户余额为：" + acct.getBalance());
		acct.withdraw(2500);
		System.out.println("您的账户余额为：" + acct.getBalance());
		acct.deposit(3000);
		System.out.println("您的账户余额为：" + acct.getBalance());
		
		System.out.println("月利率为：" + (acct.getMonthlyInterest() * 100) +"%");
		
		
		
		
	}
}