Java学习之路——类与类之间的关系+修饰符

Java学习之路——类与类之间的关系+修饰符

类与类之间的关系

A is–a B 泛化(继承 实现)

A has–a B 包含(组合 聚合 关联)

A uas–a B 依赖(依赖)

1.继承

子类继承父类，通过一个关键字:extends

子类可以调用父类中的(public protected)属性和方法，当做自己的来使用

子类可以添加自己独有的属性和方法

子类从父类中继承过来的方法不能满足子类需要，可以在子类中重写(覆盖)父类的方法

每一个类都有继承类,如果不写extends关键字，默认集成Object,如果写了则继承extends后面的父类

可以理解为Object类非常重要,是任何一个引用类型的父类(直接或间接的继承Object),Object类没有父类

Java中继承是单个存在的(单继承),每一个类只能有一个继承类(在extends关键字后面只能写一个类),可以通过传递的方式实现多继承的效果

* 继承在内存中的存储形式 *

关于this和super的使用

1.this和super都是指代词  代替的是对象
2.this代替的是当前执行方法时的那个对象，不一定是当前类的
3.super代替的是当前执行方法时的对象的父类对象
都能调用一般属性和一般方法
可以放置在类成员的任意位置(属性 方法 构造 块)
		注意调用一般方法的时候可以来回互相调用,执行可能会产生问题(StackOverflowError)
可以调用构造方法(放在构造方法的第一行)
		this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行
		构造方法之间不能来回互相调用(不能通过编译)

继承代码体现

public class Animal {
    /* 父类的属性 */
    public String name;
    /* 父类的方法 */
    public void eat(){
        System.out.println("父类:动物的吃饭方法");
    }
    public void sleep(){
    	this.eat();
        System.out.println("父类:动物的睡觉方法");
    }
}

public class People extends Animal {
    /* 父类方法重写 */
    public void eat(){
    	super.eat();
        System.out.println("重写父类:人类的吃饭方法");
    }
    /* 子类独有的属性或方法 */
    public void study(){
        System.out.println("子类:人类的学习方法,Good good study，day day up.");
    }
}

public class Test {
    public static void main(String[] args) {
        People people = new People();
        /*
        * 没有super时，this代替的是当前执行方法时的对象，所以是people
        * 没有this时，super代替的是当前执行方法时的对象的父类对象，所以是animal
        * */
        people.eat();
    }
}

2.has–a 包含(组合 聚合 关联)

从亲密程度来讲还是有区别的

组合:整体和部分的关系，不可分割，要出现都出现，要消亡都消亡。(人和大脑，人和心脏的关系)

聚合:整体和部分的关系，创建时有可能是分开的。(汽车和车轮子，电脑和主板)

关联:整体和部分的关系，可以分割，后来形成一起。(人有汽车，人有电脑)

从Java程序来描述这样的关系:通过一个类的对象当做另一个类的属性来存储。

包含代码体现

/* 汽车类 */
public class Car {
    //品牌
    public String brand;
    //型号
    public String type;
    //颜色
    public String color;
    //车里面有一个轮子(包含-聚合关系)
    public Wheel wheel;
    //构造方法
    public Car(){}

    public Car(String brand, String type, String color, Wheel wheel) {
        this.brand = brand;
        this.type = type;
        this.color = color;
        this.wheel = wheel;
    }
    //描述车的方法
    public void showCar(){
        System.out.println("这是一辆"+ brand +"牌" + type + "型号" + color + "的小汽车.");
        System.out.println("车上搭载着" + wheel.brand + "牌的" + wheel.size + "尺寸" + wheel.color + "颜色的车轮子");
        wheel.turn();
    }
}

/* 车轮类 */
public class Wheel {
    //品牌
    public String brand;
    //尺寸
    public int size;
    //颜色
    public String color;
    //构造方法
    public Wheel(){}

    public Wheel(String brand,int size,String color){
        this.brand = brand;
        this.size = size;
        this.color = color;
    }
    //车轮子旋转的行为
    public void turn(){
        System.out.println("车轮子可以旋转");
    }
}

public class Test {
    public static void main(String[] args) {
         Car car = new Car("宝马","Z4","宝石蓝色",new Wheel("米其林",400,"酷黑"));
        car.showCar();
    }
}

3.uas–a 依赖(依赖)

不是整体和部分的关系，而是因为某一件事情产生了联系

类之间临时组合在一起，行为(方法)一旦执行完毕后关系即解散

Java程序体现的形式为:一个类的方法中使用到了另一个类的对象。可以在方法中传递参数;可以在方法中自己创建

举例:屠夫(类) 杀 猪(类)。屠夫可以做一件事情–杀猪。而杀猪这个行为则需要一头猪，行为完成，关系消失。

包含代码体现

/* 描述猪 */
public class Pig {
    //名字
    public String name;
    //体重
    public int weight = 20;

    public Pig(){

    }
    public Pig(String name){
        this.name = name;
    }
    //描述一个方法，描述猪被杀了
    public void bekilled(){
        System.out.println(this.name + ":哎呀，不小心被杀了");
    }
}

/* 描述屠夫类 */
public class Butcher {
    /*
    * 省略屠夫的属性
    * */

    //描述一个屠夫杀猪的方法，参数是一头猪
    public void killPig(Pig pig){
        pig.bekilled();
    }
}

public class Test {
    public static void main(String[] args) {
         Butcher butcher = new Butcher();
         //需要杀的这头猪
        Pig pig = new Pig("乔治");
        pig.growUp(5);
        butcher.killPig(pig);
    }
}

4.设计类的关系遵循的原则

高内聚，低耦合

耦合度:[紧密] 继承(实现) > 包含 > 依赖

修饰符

权限修饰符

public 公共的 – 对所有类可见。使用对象：类、接口、变量、方法

protected 受保护的 – 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

默认不写 默认的 – 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private 私有的 – 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

权限修饰符可以用来修饰 类本身 和 类中的成员(程序块除外)

权限修饰符用来修饰类的时候只有两个可以用(public 和 默认不写)

权限修饰符都可以用来修饰类中的其他成员

权限修饰符	当前类	同一包	子孙类(同一包)	子孙类(不同包)	其他包 (package路径不同)
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N 子类实例可以访问其从父类继承而来的 protected 方法 不能访问父类的protected方法	N
默认不写	Y	Y	Y	N	N
private	Y	N	N	N	N

特征修饰符

final 最终的/不可更改的

static 静态的

abstract 抽象的

native 本地的

transient 瞬时的/短暂的

synchronized 同步的

volatile 不稳定的

扩展:方法重写和方法重载的区别

	方法重写override	方法重载overload
类	产生两个继承关系的类 子类重写父类的方法	一个类中的一组方法
权限	子类可以大于等于父类	没有要求
特征	final static abstract 父类方法是final 子类不能重写 父类方法是static 子类不存在 父类方法是abstract 子类必须重写 (子类是具体类必须重写,否则子类是抽象类,可以不重写)	没有要求
返回值	子类可以小于等于父类	没有要求
名字	子类与父类一致	一个类中的好多方法名必须一致
参数	子类与父类一致	每一个方法的参数必须不一致 (个数,类型,顺序)
异常	如果父类方法抛出的是运行时异常 子类可以不予理会 如果父类方法抛出的是编译时异常 子类抛出异常的个数少于等于父类 子类抛出异常的类型小于等于父类	没有要求
方法体	子类的方法内容应该与父类不一致	每一个重载的方法执行过程应该不一致

扩展:Object类中的方法

hashCode():将对象在内存中的地址经过计算得到一个int整数

equals():用来比较两个对象的内容,是Object类中继承过来的方法,默认效果比较地址

toString():打印输出时将对象变成String字符串

getClass():获取对象对应类的类映射(反射)

wait():线程进入挂起等待状态，存在方法重载

notify():线程唤醒

notifyAll():唤醒所有

finalize():权限修饰符是protected,在对象被GC回收的时候,默认调用执行的方法

clone():权限修饰符是protected,为了克隆对象