java基础（8）

类之间联系的方式

• 需求
  按照面向对象思想，要完成一个功能，需要多个对象共同协作，互相作用

• 方式

  • 关联方式（has -a）：将一个类作为另外一个类的属性存在
  • 依赖方式（use -a）:将一个类作为另外一个类的方法参数的联系方式
  • 继承（实现）（is-a）：使用一个公共类来封装其他类中所需要的元素，让各个功能类和该类发生关系。

• 关联方式与依赖方式的区别：

  • 从不同对象实现同一方法所用的数据相同与否。若不同对象所使用的数据均不同，则采用的是关联方式。若使用的数据相同则采用依赖方式。
  • 使用引用类的方法是否占大多数。若是，则采用关联方式。若不是，则采用依赖方式。
  • 从内存的角度看，关联方式将A类作为B类的属性来使用，B类存在内存，则A类也一定存在内存，这样占用的内存太多。而依赖方式则是将A类作为B类方法的参数，是一个局部变量，当方法调用结束后，A类占的内存也将释放。

• 继承的注意事项：

  • 子类不能继承父类的私有属性
  • 子类不继承父类的构造的方法，但能通过super关键字调用
  • 不能硬性地使类之间发生继承关系
  • java类是单继承
  • 创建子类对象时，会默认先调用父类无参数的构造方法，所以，必须在父类中定义一个无参数的构造方法

super关键字

• 前提：发生继承的前提下，子类中

• 概念：代表了父类的引用或者父类对象的引用

• 作用：

  • 在子类中，访问父类的成员
  • 在子类的构造方法中，调用父类的构造方法
  • super关键字调用父类的构造方法注意事项：
    • 如果在子类的构造方法上没有指定调用父类的构造方法，那么java会在子类的构造方法上面加上super语句
    • super关键字调用父类的构造方法时，该语句必须是子类构造方法的第一句。
    • super与this关键字不能同时出现在同一构造方法中调用其他的构造方法。

• super关键字与this关键字的区别：

  • 代表的事物不一致

    • super关键字代表了父类的引用或者父类对象的引用。
    • this关键字代表的是所属方法的调用者对象，或者本类对象的引用

  • 使用的前提不一致

    • super关键字必须要有继承关系下才能使用
    • this关键字是在本类中使用

  • 调用构造方法的区别

    • super调用的是父类的构造方法
    • this调的是本类的构造方法

方法的重写

• 前提：发生的继承情况下，子类对父类中的同名方法进行重新实现。可以用@Override注释
• 条件：
  • 方法名相同
  • 参数列表相同
    只要满足上述两个条件即可是重写
• 注意事项：
  • 必须发生继承或者实现关系中
  • 方法名和参数列表必须相同，但方法体可以随意实现。
  • 重写方法的访问权限只可以扩大或者保持，不能缩小
  • 重写方法的返回值类型只可以缩小或者保持，不能扩大
  • 重写方法抛出的异常不能比父类的方法大

测试用例及说明

package com.xzy.class_connection;
/**
 * 父类
 * @author abi
 *
 */
public class Animal {
	private String name;
	private char sex;
	private double height;
	private double weight;
	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Animal(String name, char sex, double height, double weight) {
		super();
		this.name = name;
		this.sex = sex;
		this.height = height;
		this.weight = weight;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public double getHeight() {
		return height;
	}
	public void setHeight(double height) {
		this.height = height;
	}
	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
}

package com.xzy.class_connection;
/**
 * 子类及测试
 * @author abi
 *
 */
public class Cat extends Animal{
	private int age;
	private String name;
	
	public Cat(String name, char sex, double height, double weight,int age) {
		super(name, sex, height, weight);
		// TODO Auto-generated constructor stub
		this.age = age;
	}
	public Cat() {
		//super();
		// TODO Auto-generated constructor stub
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String getName() {
		//return super.getName();
		return name;
	}
	@Override
	public void setName(String name) {
		//super.setName(name);
		this.name = name;
	}

	public void print() {
		System.out.println(super.getName()+"\t"+super.getSex()+"\t"+super.getHeight()+"\t"+super.getWeight());
		System.out.println(getName()+"\t"+getAge()+"\t"+getSex()+"\t"+getHeight()+"\t"+getWeight());
	}
	public static void main(String[] args) {
		Cat cat = new Cat("小红",'女',100.0,25.3,5);
		cat.setName("tiger");
		cat.print();
	}
}

通过运行此例，可以看到在有继承的情况下，创建一个子类对象，会附带创建一个父类对象

父类的对象一定不是子类的对象
子类的对象一定是父类的对象