对象关系的研究《大学我玩够了你呢？30天轻松搞定 Java》

对象关系的研究

1.继承关系

code:

public class 继承关系 {
    public static void main(String[] args) {
        BMW bmw = new BMW();
        //BWM类所创建的对象拥有父类Car的所有实例成员
        bmw.beautiful();
        bmw.driving();
        bmw.engine();
        bmw.wheel();
    }
}
class Car{//汽车类
    void engine(){//发动机

    }
    void wheel(){//车轮

    }
}
class BMW extends Car{//宝马车，拥有汽车类的所有属性并且拥有自己的特有属性
    void beautiful(){//美丽的外表

    }
    void driving(){//强劲的动力

    }
}

继承的概述:

1. 被继承的类被称为父类（超类），由继承而得到的新类被称为子类
2. 父类可以是Java类库中的类，也可以是自己写的类
3. 一个子类是父类的特定版本，它继承了父类所有的实例变量和方法，同时添加了自己的特有属性
4. Java不支持多重继承，即子类只能有一个父类
5. 使用extends 关键字实现继承
6. 如果一个类的声明中没有使用extends关键字，那么这个类默认继承Object类

子类的继承性:

1. 子类和父类在同一个包中时，子类不能访问声明为private的父类成员（私有成员）
2. 子类和父类不在同一个包中时，那么子类只能继承父类声明为protected和public的成员，不能继承私有成员和友好成员

2.关联关系

code:

public class 关联关系 {
}
class Book{
    int id;
    String name;
    BookExtend bookExtend = new BookExtend();//Book类引用了一个类型为被关联类BookExtend的全局变量

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public BookExtend getBookExtend() {
        return bookExtend;
    }

    public void setBookExtend(BookExtend bookExtend) {
        this.bookExtend = bookExtend;
    }
}
class BookExtend{
    int id;
    String name;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

关联关系：
体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

3.聚合与组合

code:

public class 聚合与组合 {

}
class GooseGroup{//雁群类
    public Goose goose;
    public int amount;
    public GooseGroup(Goose goose){//大雁类的构造函数
        this.goose = goose;
    }
    void show() {
        System.out.println("这是一个大雁群，共有"+amount+"只大雁");
    }
    public Goose getGoose() {
        return goose;
    }

    public void setGoose(Goose goose) {
        this.goose = goose;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }
}
class Goose{//大雁类
    public Wings wings;
    public void show(){
        System.out.println("我是一只自由的大雁");
    }
    public Goose(){//大雁类的构造函数

        wings = new Wings();
    }
    public Wings getWings() {
        return wings;
    }

    public void setWings(Wings wings) {
        this.wings = wings;
    }
}
class Wings{//翅膀类
    public void show(){
        System.out.println("我有丰满的羽翼");
    }
}

代码分析：

1. 聚合关系的类里含有另一个类作为参数
   雁群类（GooseGroup）的构造函数中要用到大雁（Goose）作为参数把值传进来 大雁类（Goose）可以脱离雁群类而独立存在
2. 组合关系的类里含有另一个类的实例化
   大雁类（Goose）在实例化之前 一定要先实例化翅膀类（Wings） 两个类紧密耦合在一起 它们有相同的生命周期 翅膀类（Wings）不可以脱离大雁类（Goose）而独立存在
3. 信息的封装性不同
   在聚合关系中，客户端可以同时了解雁群类和大雁类，因为他们都是独立的
   而在组合关系中，客户端只认识大雁类，根本就不知道翅膀类的存在，因为翅膀类被严密的封装在大雁类中。

• 聚合关系
  聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；
• 组合关系
  组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；
• 总体比较
  几种关系所表现的强弱程度依次为：组合>聚合>关联；
  聚合跟组合其实都属于关联 只不过它们是两种特殊的关联 因为本是同根生 所以它们之间难免会有相似之处

4.继承下的方法重写

code:

public class 继承下的方法重写 {
}
//方法的重写、使用super调用父类的构造器
class test1{
    public static void main(String[] args) {
        B b = new B();//通过B类的构造函数创建对象，先调用父类A的含参构造器，然后执行了smile和cry方法
        System.out.println();
        C c = new C();//通过C类的构造器创建对象，先调用父类A的无参构造器，然后打印一句话
    }
}
class A{
    A(){
       System.out.println("所调用的是A类中不带参数的构造器");
    }
    A(int a){
        System.out.println("所调用的是A类中带参数的构造器");
    }
    void smile(){
        System.out.println("我开心的笑了");
    }
    void cry(){
        System.out.println("我这次真的伤心了");
    }
}
class B extends A{
    B(){//无参构造函数
        super(10);//用super关键字调用父类带参数的构造方法
        System.out.println("我是类B，我继承了A");
        smile();//调用的是重写过后的方法
        cry();//调用的是从父类继承的cry方法
    }
    void smile(){//重写smile方法
        System.out.println("看！我在傻傻的笑！");
    }
}
class C extends A{
    C(){//默认调用父类的无参构造器   相当于“ super(); ”
        System.out.println("我是类C，我继承了类A");
    }
}
//使用super操作被隐藏的成员变量和方法
class test2{
    public static void main(String[] args) {
        E e = new E();
        e.smile();
    }
}
class D{
    int a = 10;
    D(){
        System.out.println("我是类D，我被E继承了");
    }
    void smile(){
        System.out.println("我是类A的smile方法");
    }
}
class E extends D{
    int a;
    int b;
    E(){//"super();"默认调用父类无参构造器
        System.out.println("我是类E的a变量，"+a);
        b = super.a;//利用super操作被隐藏的变量a
        System.out.println("我是类E的b变量，"+b);
    }
    void smile(){
        super.smile();//利用super操作被隐藏的smile方法
        System.out.println("我是类E的smile方法");
    }
}

test1 输出台：

所调用的是A类中带参数的构造器
我是类B，我继承了A
看！我在傻傻的笑！
我这次真的伤心了

所调用的是A类中不带参数的构造器
我是类C，我继承了类A

Process finished with exit code 0

test2 输出台：

我是类D，我被E继承了
我是类E的a变量，0
我是类E的b变量，10
我是类A的smile方法
我是类E的smile方法

Process finished with exit code 0

1. 方法重写

• 子类中定义一个方法，并且这个方法的名字、返回类型、参数类型及参数的个数与父类继承的方法完全相同。
• 通过方法重写，子类可以把父类得状态转变成自己的状态和行为。
• 一旦方法重写成功，所继承的父类的方法会被隐藏，子类如果调用吗、，则会调用重写后的方法。
• 如果子类想要使用被隐藏的方法，必须使用super关键字。

2. super关键字

• 使用super调用父类的构造方法
• 子类不继承父类的构造方法。如果想要调用，可以使用super，但super语句必须是子类构造方法中的第一条语句。
• 子类在创建对象时，子类的构造方法总是调用父类的某个构造方法。
  如果父类有多个构造方法，那么子类默认调用的是那个不带参数的
  如果父类只有一个带参数的构造方法，那么在子类中必须在自己的构造方法中使用super语句来调用父类带参数的构造方法，否则报错
• 如果子类的构造方法中，没有super语句，那么系统默认有“super（）；”存在，即调用父类的不带参数的构造方法
• 使用super操作被隐藏的父类的成员变量和方法
• 只有使用super关键字才能访问被隐藏的变量和方法

5.Java多态实现

code：

public class Java多态实现 {
}
class Animal{
    Animal(){
        System.out.println("猫、狗都是动物");
    }
    void eat(){
        System.out.println("动物都要吃东西");
    }
    void run(){
        System.out.println("动物都会跑");
    }
}
class Dog extends Animal {
    void eat() {
        System.out.println("狗爱吃骨头");
    }
}
class Test{
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.eat();
        Dog dog2 = new Dog();
        Animal animal;
        animal = dog2;//多态性
        animal.eat();//dog2有eat方法就调用Dog类方法
        animal.run();//dog2没有run方法就调用Animal方法
    }
}

输出台·：

猫、狗都是动物
狗爱吃骨头
猫、狗都是动物
狗爱吃骨头
动物都会跑

Process finished with exit code 0

Java多态实现：

1. 多态性是指不同类的对象对同一消息做出响应。
2. 包括参数多态性和包含多态性。
3. 当我们将子类对象的引用传给声明为父类的一个对象变量，如果子类

6.final方法

code:

public class final方法 {

}
final class FinalClass{//final类

}
//class ClassOne extends FinalClass{ 非法，final类无法被继承
//
//}
class ClassTwo{
    final int a=10;//final变量
    final void test(){//final方法
        int b = 10;
    }
}
class ClassThree extends ClassTwo {
//    void test(){ 非法，final方法不可被重写
//    }
//    a=10; 非法，final变量不可被修改
}

final方法:

1. 以final修饰的成员变量，对象虽然可以操作使用它，但不你对它进行更改更改操作
2. 以final修饰的类，不可以被继承，即final类没有子类（出于安全性的考虑）
3. final修饰的方法不可以被子类重写，同时，final方法的行为是不允许子类更改的

7.Object类

code:

public class Object类 {
    }
class  Otest{
    private String username = "system";
    private String passward = "manager";
    Otest(String name,String pwd){
        if (name.equals(null)||pwd.equals(null)) {
            System.out.println("用户名或密码为空!");
        } else {
            if (username.equals(name)&&pwd.equals(pwd)) {
                System.out.println("登录成功!");
            } else {
                System.out.println("登录失败!");
            }
        }
    }
    public static void main(String[] args) {
        Otest otest = new Otest("system","manager");
    }
}

输出台：

登录成功!

Process finished with exit code 0

Object类:

1. Object类是多有类的父类，即Java中的没一个类都是由Object类扩展而来
2. Object类的方法和用途

方法	用途
Object clone	创建与该对象的类相同的新对象
Boolean equals（Object）	比较两对象是否相等
void finalize（）	当垃圾回收器确定不存在对该对象的更多引用时，对象的垃圾回收器调用该方法
class getClass（）	返回一个对象的运行时间类
int hasCode	返回该对象的散列码值
void notify（）	激活等待在该对象的监视器上的一个进程
String toString（）	返回该对象的字符串表示
void wait（）	等待这个对象另一个更改线程的通知
void wait(long,int)	等待这个对象另一个更改线程的通知

3. Object类提供的只是一些基本的方法，我们在编写自己的类时经常需要覆盖这些方法，一方面是加强功能，另一方发面是为了适应当前的情况