012面向对象编程（中）-1

继承性

练习1：圆与圆柱

package com.atguigu.exer1;

public class Circle {
	private double radius;

	public Circle() {
		this.radius = 1;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	public double getRadius() {
		return radius;
	}

	public double findArea() { // 计算圆的面积
		return Math.PI * radius * radius;
	}

}

package com.atguigu.exer1;

public class Cylinder extends Circle {
	private double length;

	public Cylinder() {
		this.length = 1;
	}

	public void setLength(double length) {
		this.length = length;
	}

	public double getLength() {
		return length;
	}

	public double findVolume() { // 计算圆柱体积
		return super.findArea() * length;
	}

	public double findArea() { // 重写父类方法，计算圆柱表面积
		return getRadius() * 2 * Math.PI * getLength() + super.findArea() * 2;
	}
}

package com.atguigu.exer1;

public class CylinderTest {
	public static void main(String[] args) {
		Cylinder cylinder = new Cylinder();
		cylinder.setRadius(4);
		cylinder.setLength(10);
		// 重写前
		// System.out.println("圆面积: " + cylinder.findArea()); //圆面积
		// 重写后
		System.out.println("圆柱表面积: " + cylinder.findArea());// 圆柱表面积
		System.out.println("圆柱体积: " + cylinder.findVolume()); // 圆柱体积

	}
}

方法的重写

四种访问权限修饰符

练习1：体会权限调用

package com.atguigu.exer2;

public class Parent {
	private int f1 = 1;
	int f2 = 2;
	protected int f3 = 3;
	public int f4 = 4;

	private void fm1() { //The method fm1() from the type Parent is never used locally
		System.out.println("in fm1() f1=" + f1);
	}

	void fm2() {
		System.out.println("in fm2() f2=" + f2);
	}

	protected void fm3() {
		System.out.println("in fm3() f3=" + f3);
	}

	public void fm4() {
		System.out.println("in fm4() f4=" + f4);
	}
}

package com.atguigu.exer2;

class Child extends Parent {
	private int c1 = 21;
	public int c2 = 22;

	private void cm1() {
		System.out.println("in cm1() c1=" + c1);
	}

	public void cm2() {
		System.out.println("in cm2() c2=" + c2);
	}

	public static void main(String[] args) {
		Parent p = new Parent();

		// System.out.println(p.f1);//The field Parent.f1 is not visible
		System.out.println(p.f2);
		System.out.println(p.f3);
		System.out.println(p.f4);
		// p.fm1();//The method fm1() from the type Parent is not visible
		p.fm2();
		p.fm3();
		p.fm4();

		Child c = new Child();
		System.out.println(c.f2);
		System.out.println(c.f3);
		System.out.println(c.f4);

		System.out.println(c.c1);
		System.out.println(c.c2);
		c.cm1();
		c.cm2();
		c.fm2();
		c.fm3();
		c.fm4();

	}
}

super关键字

练习1：super调用

package com.atguigu.exer3;

import java.sql.Date;

public class Person {
	private String name;
	private int age;
	private Date birthDate;

	public Person(String name, int age, Date d) {
		this.name = name;
		this.age = age;
		this.birthDate = d;
	}

	public Person(String name, int age) {
		this(name, age, null);
	}

	public Person(String name, Date d) {
		this(name, 30, d);
	}

	public Person(String name) {
		this(name, 30);
	}
}

package com.atguigu.exer3;

public class Student extends Person {
	private String school;

	public Student(String name, int age, String s) {
		super(name, age);
		school = s;
	}

	public Student(String name, String s) {
		super(name);
		school = s;
	}

	// 编译出错: no super(),系统将调用父类无参数的构造器。
	// public Student(String s) { //Implicit super constructor Person() is
	// undefined. Must explicitly invoke another constructor
	// school = s;
	// }
}

练习2：综合练习

Account

package com.atguigu.java;

public class Account {
	private int id;
	private double balance;
	private double annualInterestRate;

	public Account(int id, double balance, double annualInterestRate) {
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}

	public double getBalance() {
		return balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}

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

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

	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}

	public double getMonthlyInterest() {
		return annualInterestRate / 12;
	}

	public void withdraw(double amount) {
		if (amount <= balance) {
			balance -= amount;
		} else {
			System.out.println("余额不足！");
		}
	}

	public void deposit(double amount) {
		balance += amount;
	}
}

CheckAccount

package com.atguigu.java;

/*
创建 Account 类的一个子类 CheckAccount 代表可透支的账户，该账户中定义一个属性
overdraft 代表可透支限额。在 CheckAccount 类中重写 withdraw 方法，
 */
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;
	}

	@Override
	public void withdraw(double amount) {
		if (amount <= getBalance()) { // 余额满足扣除金额
			super.withdraw(amount);
		} else if (amount <= (getBalance() + overdraft)) { // 余额加透支额度满足扣除金额
			overdraft = overdraft - (amount - getBalance());
			super.withdraw(getBalance());
		} else {
			System.out.println("超过可透支额的限额");
		}
	}

	public double getOverdraft() {
		return overdraft;
	}
}

AccountTest

package com.atguigu.java;

public class AccountTest {
	public static void main(String[] args) {
		// 测试Account功能
		/*
		 * 写一个用户程序测试 Account 类。在用户程序中，创建一个账号为 1122、余额为 20000、 年利率 4.5%的 Account
		 * 对象。使用 withdraw 方法提款 30000 元，并打印余额。 再使用 withdraw 方法提款 2500 元，使用
		 * deposit 方法存款 3000 元，然后打印余额和月利 率
		 */
		Account account = new Account(1122, 20000, 0.045);
		account.withdraw(30000);
		System.out.println("您的账户余额为: " + account.getBalance());
		account.withdraw(2500);
		account.deposit(3000);
		System.out.println("您的账户余额为: " + account.getBalance());
		System.out.println("月利率为: " + (account.getMonthlyInterest() * 100) + "%");

		System.out.println("**********************");

		// 测试CheckAccount功能
		/*
		 * 写一个用户程序测试 CheckAccount 类。在用户程序中，创建一个账号为 1122、余 额为 20000、年利率
		 * 4.5%，可透支限额为 5000 元的 CheckAccount 对象。 使用 withdraw 方法提款 5000
		 * 元，并打印账户余额和可透支额。 再使用 withdraw 方法提款 18000 元，并打印账户余额和可透支额。 再使用 withdraw
		 * 方法提款 3000 元，并打印账户余额和可透支额。
		 */
		// 第一次测试
		CheckAccount checkAccount = new CheckAccount(1122, 20000, 0.045, 5000);
		checkAccount.withdraw(5000);
		System.out.println("您的账户余额: " + checkAccount.getBalance());
		System.out.println("您的可透支额: " + checkAccount.getOverdraft());
		System.out.println();
		// 第二次测试
		checkAccount.withdraw(18000);
		System.out.println("您的账户余额: " + checkAccount.getBalance());
		System.out.println("您的可透支额: " + checkAccount.getOverdraft());
		System.out.println();
		// 第三次测试
		checkAccount.withdraw(3000);
		System.out.println("您的账户余额: " + checkAccount.getBalance());
		System.out.println("您的可透支额: " + checkAccount.getOverdraft());
		System.out.println();

	}
}

多态性

练习1：多态是运行时行为

package com.atguigu.exer4;

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：多态性的练习

package com.atguigu.exer4;

//考查多态的笔试题目：
public class InterviewTest1 {

	public static void main(String[] args) {
		Base base = new Sub();
		base.add(1, 2, 3);
		/*
		 * 父类引用指向子类对象，当子类add(int a, int[] arr)注释时，调用add方法使用的是父类的add，
		 * 而不使用子类add(int a, int b, int c)的原因是不满足重写条件，子类add(int a, int[] arr)构成重写
		 */

		Sub s = (Sub) base;
		s.add(1, 2, 3);
	}
}

class Base {
	public void add(int a, int... arr) {
		System.out.println("base");
	}
}

class Sub extends Base {

	// public void add(int a, int[] arr) {
	// System.out.println("sub_1");
	// }

	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}

}

重载(overload)和重写(overried)的区别

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。