类和类的关系 is a关系(泛化):继承 实现 has a关系(包含):组合 聚合 关联 use/need a关系:依赖

1.类的关系-继承

is a关系

1.子类需要通过关键字extend继承父类 2.子类可以继承父类的属性和方法,当做自己的使用,也可以添加自己独有的属性和方法 3.当父类方法不能满足子类的需求时,子类可以重写父类的方法

方法重写与方法重载的区别
对比项\名称 方法重写(Override) 方法重载(overload)
产生两个继承关系的类(子类继承父类,子类重写父类方法) 一个类中的一组方法
权限修饰符 子类的权限修饰符可以大于等于父类 没有要求
特征修饰符 final static abstract
父类是final,子类不能重写
父类是static,子类不存在重写
父类是abstract,子类必须重写
没有要求
返回值类型 子类的返回值小于等于父类 没有要求
属性名称 子类的名称必须和父类一致 一个类中的方法名必须一致
参数 子类必须与父类一致 每一个方法参数必须不一致(个数,类型,顺序)
异常 若父类抛出运行时异常,子类可以重写,也可以不重写
若父类抛出编译时异常,子类抛出异常的个数和类型都要少于等于父类
没有要求
方法体 子类的方法内容与父类不一致 重载方法执行过程不一致

4.每一个类都有继承类,如果不写extend关键字,则默认继承Object类 Object类中的方法: hashCode() 将对象在内存中的地址经过计算得到一个int整数 equals() 比较两个对象的内容(默认比较方式为:==) toString() 打印输出时将对象变成String字符串 getClass() 获取对象对应类的类映射 wait() 线程进入等待状态 notify() 唤醒线程 notifyAll() 唤醒所有线程 clone() 权限修饰符是protected,为了克隆对象 finalize() 权限修饰符是protected,在对象被GC回收时,默认执行的方法 final finally finalize() 5.继承是单个存在的(单继承),每一个类只能有一个继承类,在extend关键字后只能写一个类,目的是为了让类变得更加安全,但可以通过传递的方式进行多继承。 6.继承在内存中的存储形式 7.this与super 都是指代词,代替的是对象 this代替的是当前执行方法时的那个对象 super代替的是当前执行方法时对象的父类对象

2.类的关系-包含

has a关系:一个类的对象当做另一个类的属性来存储

组合:整体和部分的关系,不可分割,同时出现,同时消失 聚合:整体和部分的关系,可以分割,创建时可能是分开的,最终会在一起 关联:整体和部分的关系,可以分割,后来形成在一起的

  1. package contains;
  2. public class Wheel {
  3. public String brand;
  4. public String size;
  5. public String color;
  6. public void turn(){
  7. System.out.println("轮子转起来了");
  8. }
  9. }
  1. package contains;
  2. public class Car {
  3. public String brand;
  4. public String type;
  5. public String color;
  6. public Wheel wheel;
  7. public void showCar(){
  8. System.out.println("这是一辆"+brand+"牌"+type+"型号"+color+"的汽车");
  9. System.out.println("车上搭载着"+wheel.brand+"牌"+wheel.size+"尺寸"+wheel.color+"的轮子");
  10. wheel.turn();
  11. }
  12. }
  1. package contains;
  2. public class Test {
  3. public static void main(String[] args) {
  4. Car car = new Car();
  5. car.brand = "宝马";
  6. car.type = "Z4";
  7. car.color = "黑色";
  8. car.wheel = new Wheel();
  9. car.wheel.brand = "米其林";
  10. car.wheel.size = "500cm";
  11. car.wheel.color = "彩色";
  12. car.showCar();
  13. }
  14. }

3.类的关系-依赖

use-a(need-a) 依赖关系 依赖关系:不是整体与部分的关系,而是因为某件事情临时组合在一起,产生的关系,事情一旦做完,关系即解散, 例如:屠夫与猪 设计类的关系原则:高内聚,低耦合 耦合度:紧密 继承(实现) > 包含 > 依赖 Java程序体现的形式为: 一个类的方法中使用到了另一个类的对象,具体实现形式为: 1.在方法中传递参数 2.在方法中自己创建

  1. package Rely;
  2. public class pig {
  3. public String name;
  4. public int weight = 20;
  5. public pig() {}
  6. public pig(String name) {
  7. this.name = name;
  8. }
  9. public int GrowUP(int month){
  10. for (int i = 1;i<=month;i++){
  11. this.weight *= 2;
  12. }
  13. return this.weight;
  14. }
  15. public void BeKilled(){
  16. System.out.println(name+"在"+this.weight+"斤时被杀了");
  17. }
  18. }
  1. package Rely;
  2. public class Butcher {
  3. public void KillPig(){
  4. pig pig = new pig("小猪");
  5. pig.GrowUP(5);
  6. pig.BeKilled();
  7. }
  8. }
  1. package Rely;
  2. public class Test {
  3. public static void main(String[] args) {
  4. Butcher bu = new Butcher();
  5. bu.KillPig();
  6. }
  7. }