Java基础面向对象的特征继承2和多态性1

面向对象的第二大特征：继承性

3.一个子类还可以派生别的子类？

• 是可以的

//小学生
public class SchoolChild extends Student {
	
	public void game(){
		System.out.println("你是一个小学生，不要玩游戏");
	}

}

Testperson.java

	//创建一个小学生类
		SchoolChild sc=new SchoolChild();
		sc.game();
		sc.setId(1001);
		sc.eat();
		sc.setAge(12);
		sc.setName("李四");
		System.out.println(stu.getName()+":"+stu.getAge()+":"+stu.getId());

4.一个父类可以有多个子类，一个子类可以有多个父类吗？

• 不可以，java的继承是单继承

练习1.

(1)定义一个ManKind类，包括
成员变量 int sex 和 int salary；
方法 void manOrWorman()：根据sex的值显示“man”(sex1)或者“women”(sex0)；
方法 void employeed()：根据salary的值显示“no job”(salary ==0)或者“ job”(salary!=0)。
(2)定义类Kid继承ManKind，包括
成员变量 int yearsOld；
方法 printAge() 打印 yearsOld 的值。
(3)在测试类TestKid的main方法中实例化Kid的对象 someKid，用该对象访问其父类的成员变量及方法。

public class ManKind {
	private int sex;//性别
	private int salary;//薪水
	public int getSex() {
		return sex;
	}
	public void setSex(int sex) {
		this.sex = sex;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public ManKind(int sex, int salary) {
		super();
		this.sex = sex;
		this.salary = salary;
	}
	public ManKind() {
		super();
	}
	
	//判断性别是否是男或女
	public void manOrWorman(){
		if(this.sex==1){
			System.out.println("man");
		}else if(this.sex==0){
			System.out.println("woman");
		}else{
			System.out.println("年龄不合法");
		}
	}
	
	//判断薪水
	public void employeed(){
		if(this.salary!=0){
			System.out.println("job");
		}else if(salary==0){
			System.out.println("no job");
		}else{
			System.out.println("输入不合法");
		}
	}
	
	
}

---

public class Kid extends ManKind {
	
	private int yearOld;

	public int getYearOld() {
		return yearOld;
	}

	public void setYearOld(int yearOld) {
		this.yearOld = yearOld;
	}
	
	public void printAge(){
		System.out.println(this.yearOld);
	}
}

public class TestKid {

	public static void main(String[] args) {
		//创建kid对象
		Kid k=new Kid();
		k.setSex(0);
		k.setSalary(10000);
		k.employeed();
		k.manOrWorman();
		k.setYearOld(1);
		k.printAge();

	}

}

计算圆面积

public class Circle {
	
	private double radius;//半径

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}
	
	public Circle(){
		this.radius=1;
	}
	
	//计算圆的面积
	public double findArea(){
		return radius*radius*3.14;
	}
}

---

计算圆柱面积

public class Cylinder extends Circle {
	private double length;//高

	public double getLength() {
		return length;
	}

	public void setLength(double length) {
		this.length = length;
	}
	
	public Cylinder(){
		this.length=1;
	}
	//重写父类计算面积的方法，计算圆柱的表面积
	public double findArea(){
		//return this.getRadius()*this.getRadius()*3.14*2+3.14*this.getRadius()*length*2;
	    return super.findArea()*2+3.14*this.getRadius()*length*2;
	
	}
	
	//圆柱的体积
	public double findVolume(){//默认会调用子类重写的方法
//		return this.getRadius()*this.getRadius()*3.14*length;
		return super.findArea()*length;
	}
}

public class TestCylinder {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建圆柱对象
		Cylinder cy=new Cylinder();
		cy.setRadius(2);
		cy.setLength(3);
		//调用计算体积的方法
		System.out.println("圆柱的体积为："+cy.findVolume());
		
		//创建一个圆对象
		Circle c=new Circle();
		c.setRadius(2);
		//调用计算圆面积的方法
		System.out.println(c.findArea());//
		
		System.out.println(cy.findArea());//应该计算圆柱的表面积  方法重写？
	}

}

5.方法重写

• 如果父类的方法满足不了子类要求时，子类可以对父类的方法进行重写 （重点）
• 重写规则：
• (1).要求子类重写的方法名、参数列表、返回值类型必须和父类完全一致
• (2),子类重写方法的访问修饰符权限不能低于父类方法修饰符权限
• (3).子类方法和父类方法必须同为static或非static
  Student.java

//重写父类吃饭的方法
	public static void eat(){
		System.out.println("我是一名学生，我是祖国的花朵，我应该吃一些营养的东西");
	}

6.重载（overload）和重写(override)的区别: （重点整理）

• (1).方法重载必须在同一个类中，方法重写必须存在继承关系
• (2).方法重载要求方法名相同、参数列表必须不相同，和返回值无关
• (3).方法重写要求方法名、参数列表、返回值必须和父类一致

super关键字

可以修饰属性、方法、构造方法

• 1.当前子类和父类的属性出现重名时，默认会调用子类的属性，可以通过"super.属性名"的方式显示的调用父类声明

• 同名属性

• 2、子类重写父类方法后，如果子类想再次调用父类被重写的方法，可以通过"super.方法名()"的方法调用父类方法

• 3、super可以修改构造方法，通过子类构造方法中使用“super(形参)”来显示的调用父类对应的构造方法

• 注意：1.super（形参）必须声明在首行

•  2.说明this(形参)和super（形参）只能出现一个
  

•  3.在构造法方法中，不显示的通过super（形参）的方式调用父类对应的构造方法，
  

•  默认会调用父类无参的无参构造方法
  

• 如果一个类没有显示的继承谁，就继承object

public class Student extends Person {
	private int id =1002;//学号
	private String schoolName;//学校名
	
	public int getId() {
		return id;
	}

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

	public String getSchoolName() {
		return schoolName;
	}

	public void setSchoolName(String schoolName) {
		this.schoolName = schoolName;
	}
	public Student() {
		//super();//去调用父类无参构造方法了
		System.out.println("student构造方法执行了");
	}
	
	public Student(String schoolName,String name,int age) {
		super(name,age);//
		this.schoolName=schoolName;
		System.out.println("student类三个参数构造方法执行了");
		
	}

	//重写父类吃饭的方法
	public static void eat(){
		System.out.println("我是一名学生，我是祖国的花朵，我应该吃一些营养的东西");
	}
	
	public void show(){
		this.eat();//重写后的方法
		super.eat();//父类方法
		System.out.println(this.id);//学号
		System.out.println(super.id);//身份证号
	}
	

}

访问修饰符：修饰类、变量、方法、接口 （重点总结）

30%-40%面试简答

• public：公共的，在当前项目下任何地方都可以访问
• protected：受保护的，在同一个包下或者在其他子类中可以访问
• default：缺省 在同一个包下
• private：私有 ，在当前类下面访问

public class Order {
	public String oName;//订单名
	protected int oId;
	int onum;
	private double oPrice;
	
	public void method(){
		oName="电脑";
		oId=1001;
		onum=12;
		oPrice=5000;
		
	}
	
	protected void method1(){
		
	}
	
	 void method2(){
		
	}
	 
	 private void method3(){
		 
	 }

}

public class TestOrder {

	public static void main(String[] args) {
		Order o=new Order();
		o.oName="手机";
		o.oId=1001;
		o.onum=10;
//		o.oPrice=100;

	}

}

---

/生物类
public class Creator {
	
	private int age;

	public int getAge() {
		return age;
	}

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

	public Creator() {
		super();
		System.out.println("Creator构造方法执行了");
	}
	

}

//动物类
public class Animal extends Creator {
	private String name;//名字

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Animal() {
		super();
		System.out.println("Animal类构造方法执行了");
	}
	
	

}

//狗类
public class Dog  extends Animal{
	
	private String hostName;//主人的名字

	public String getHostName() {
		return hostName;
	}

	public void setHostName(String hostName) {
		this.hostName = hostName;
	}

	public Dog() {
		super();
		System.out.println("dog类的无参构造方法执行了");
	}
	

}

public class TestDog {

	public static void main(String[] args) {
		Dog d=new Dog();
		d.setAge(12);
		d.setName("旺财");
		d.setHostName("刘长安");
		
		System.out.println("age:"+d.getAge()+",name:"+d.getName()
		+",hostName:"+d.getHostName());
		

	}

}

面向对象的第三大特征：多态

1.什么是多态性？

• (1)同一个动作与不同的对象产生不同的行为
• (2)多态指的是一个对象的多种形态

2.多态的体现方式

• （1）.使用继承：不同的子类重写父类方法后，体现出来的形式不一样
• (2)接口的实现

3.形成多态的必要条件

• (1)继承：存在子类和父类的关系
• (2)接口实现：定义一个类实现对应的接口
• (3)重写：子类重写了父类的方法
• (4)重载：调用相同的方法名，实现的功能时不一样
• （5）.子类对象的多态性（重点）：父类的引用指向子类的实例