一、面向对象和面向过程的关系

1）面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做；

2）面向对象：强调了具备功能的对象，以类/对象为最小单位，考虑谁来做。

总结一手：

不管是面向过程、面向对象，都是程序设计的思路。

二、Java类/类成员

1-概述

2-类和对象的关系

3-对象的创建与使用

 4-对象的内存解析

 

（1）依赖关系

 只要在类中用到对方，它们之间就会存在依赖关系。

public class PersonServiceBean {
    private PersonDao personDao;
    public void save(Person person) {
    }
    public IDCard getIDCard(Integer personid){
        return null;
    }
    public void modify(){
        Department department = new Department();
    }
}

public class IDCard {
}

public class Department {
}

public class Person {
}

public class PersonDao {
}

（2）泛化关系

泛化关系就是继承关系，是依赖关系的特例。

public abstract class DaoSupport {
    public void save(Object entity){
    }
    public void delete(Object id){
    }
}

public class PersonServiceBean extends DaoSupport {
}

（3）实现关系

实现关系就是一个接口被一个类实现了，是依赖关系的特例。

public interface PersonService {
    public void delete(Integer id);
}

public class PersonServiceBean implements PersonService {
    @Override
    public void delete(Integer id) {
 
    }
}

（4）关联关系

        1、关联关系等同于类与类之间的联系，是依赖关系的特例。

        2、关联具有导航性：就是双向关系和单向关系。

        3、关联具有多重性

单向一对一关系：

public class IDCard {
}

public class Person {
    private IDCard idCard;
}

（5）聚合关系

聚合关系表示整体和部分的关系，整体与部分可以分开。聚合关系是关联关系的特例，同样具有导航性和多重性。

public class Computer {
    private Mouse mouse;
    private Moniter moniter;
 
    public void setMouse(Mouse mouse) {
        this.mouse = mouse;
    }
 
    public void setMoniter(Moniter moniter) {
        this.moniter = moniter;
    }
}

public class Moniter {
}

public class Mouse {
}

（6）组合关系

整体与部分的关系，但是整体与部分不可以分开。

public class Computer {
    private Mouse mouse = new Mouse();
    private Moniter moniter = new Moniter();
 
    public void setMouse(Mouse mouse) {
        this.mouse = mouse;
    }
 
    public void setMoniter(Moniter moniter) {
        this.moniter = moniter;
    }
}

三、面向对象的三大特征

前置补充：要用到的关键字

特性1-封装性

1）空参构造

2）权限修饰符

3）有参构造

特性2-继承性

补充：抽象

package com.atguigu.b_abstract;

public abstract class Employee {
    private String name;  // 员工姓名
    private int age;  // 员工年龄

    public Employee() {
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    /**
     * 员工工作的抽象方法
     */
    public abstract void work();

    // public abstract void eat();
}

package com.atguigu.b_abstract;

public  class Teacher extends Employee{
    public Teacher() {
    }

    public Teacher(String name, int age) {
        super(name, age);
    }

    @Override
    public void work() {
        System.out.println("讲师在讲课");
    }

}

package com.atguigu.b_abstract;

public class Test {
    public static void main(String[] args) {
        Teacher t1 = new Teacher("涛哥", 16);
        t1.work();
    }
}

补充：接口

怎么定义接口 ？

package com.atguigu.d_interface;

public interface USB {
    public abstract void open();
    abstract void close();

    public default void sleep(){
        System.out.println("USB休眠");
    }
}

package com.atguigu.d_interface;

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}

package com.atguigu.d_interface;

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();//接口不能直接new对象
        mouse.open();
        mouse.close();
    }

}

【默认方法:】

package com.atguigu.e_interface;

public class Mouse implements USB{
    @Override
    public void methodDef(){

        System.out.println("我是重写的接口中的默认方法");
    }
}

package com.atguigu.e_interface;

public interface USB {
    //默认方法
    public default void methodDef(){
        System.out.println("我是接口中的默认方法");
    }

    //静态方法
    public static void methodSta(){
        System.out.println("我是接口中的静态方法");
    }
}

package com.atguigu.e_interface;

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.methodDef();

        System.out.println("================");
        USB.methodSta();
    }
}

静态方法：

【接口：成员方法】

特性3-多态性

1）基本概念

package com.atguigu.h_duotai;
/**父类**/
public class Animal {
    public void eat(){
        System.out.println("动物要吃饭");
    }
}

package com.atguigu.h_duotai;
/**子类1**/
public class Dog extends Animal{
    /**有子类继承关系有方法重写**/
    public void eat(){
        System.out.println("狗啃骨头");
    }
    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

package com.atguigu.h_duotai;
/** 子类2**/
public class Cat extends Animal{
    /**有子类继承关系有方法重写**/
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    //特有方法
    public void catchMouse(){
        System.out.println("猫会抓老鼠");
    }
}


package com.atguigu.h_duotai;
/**测试类**/
public class Test01 {
    public static void main(String[] args) {
        //原始方式new对象
        Dog dog = new Dog();
        dog.eat();
        dog.lookDoor();
        System.out.println("==========");
        Cat cat = new Cat();
        cat.eat();
        cat.catchMouse();
        System.out.println("=====以下是多态形式new=====");
        //多态形式new对象
        Animal animal = new Dog();
        animal.eat();
        //animal.lookDoor();//多态前提下,不能直接调用子类特有功能
        //lookDoor是子类特有方法，不能直接调用，下述一样
        System.out.println("=======");

        Animal animal1 = new Cat();
        animal1.eat();
        //animal1.catchMouse();//多态前提下,不能直接调用子类特有功能

    }
}

2）多态成员以及成员方法的访问特点

package com.atguigu.i_duotai;
public class Fu {
    int num = 100;
    public void method(){
        System.out.println("父类中的method方法");
    }
}


package com.atguigu.i_duotai;
public class Zi extends Fu{
    int num = 10;
    public void method(){
        System.out.println("子类中的method方法");
    }
}

package com.atguigu.i_duotai;
/****/
public class Test {
    public static void main(String[] args) {
        //多态方式new一个对象
        Fu fu = new Zi();
        //成员变量没有多态性，成员方法要是有重名的直接子类重写就行了
        System.out.println(fu.num);//父类的100
        fu.method();
        System.out.println("============");
        //原始方式
        Zi zi = new Zi();
        System.out.println(zi.num);//子类的10
        zi.method();
    }
}

输出:
100
子类中的method方法
============
10
子类中的method方法

3）多态的好处

4）多态的转型

package com.atguigu.k_duotai;

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method(dog);

        Cat cat = new Cat();
        method(cat);
    }
    public static void method(Animal animal) {//Animal animal = Dog  Animal animal = Cat
        if (animal instanceof Dog){
            animal.eat();
            //向下转型
            Dog dog = (Dog) animal;//强制从dog类转为animal
            dog.lookDoor();//就可以调子类成员方法了
        }
        /***
         * 向下转型容易出现的问题:           classCastException----->类型转换异常
         *
         * 出现问题的原因：                  转型的时候，等号左右两边型号不一致
         *
         * 解决方案：做判断
         * 关键字：instanceof关键字------>用来判断某个对象是否属于某种数据类型。  返回值为布尔类型
         * 格式：
         * 对象名 instanceof 类型--》关键字前面的类型是否属于关键字后面的类型
         *
         * */

        if (animal instanceof Cat){
            animal.eat();
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

 多态练习

2）分析

3）代码实现

package com.atguigu.l_duotai;
/**
 * -USB接口类，包括开启功能、关闭功能
 * **/
public interface USB {
    void open();//不写abstract也可以
    void close();
}

package com.atguigu.l_duotai;
public class KeyBoard implements USB{
    //重写接口方法
    @Override
    public void open() {
        System.out.println("键盘开启");
    }
    @Override
    public void close() {
        System.out.println("键盘关闭");
    }
}

package com.atguigu.l_duotai;
/**Mouse类**/
public class Mouse implements USB{
    @Override
    public void open() {//重写接口方法
        System.out.println("鼠标开启");
    }
    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}

package com.atguigu.l_duotai;

public class NoteBook {
    public void start(){//成员方法
        System.out.println("开机了");
    }
/**
 * 接收TEST类传过来的Mouse对象
 *USB接收
 * USB是mouse的接口类型 USB usb = mouse
 * mouse是usb的接口实现类对象
 * 接口看成父类。接口实现类看成子类
 * 多态的体现
 * **/
    public void useUSB(USB usb){
        //  USB usb = keyBoard
        usb.open();//多态调用
        usb.close();
    }
    public void stop(){
        System.out.println("关机了");
    }
}

package com.atguigu.l_duotai;
/**
 * 定义笔记本类，具备开机，关机和使用USB设备的功能，具体是什么USB设备，笔记本不关心，
 * 只要符合USB规格的设备都可以。鼠标和键盘要想在电脑上使用，
 * 那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用
 *                  描述笔记本类，实现笔记本使用USB鼠标、USB键盘
 *
 * -USB接口，包括开启功能、关闭功能
 * -笔记本类，包含运行功能、关机功能、使用USB功能
 * -鼠标类，要符合USB
 * -键盘类，要符合USB接口
 *
 * **/
public class Test01 {
    public static void main(String[] args) {
        NoteBook noteBook = new NoteBook();
        noteBook.start();//笔记本类调用笔记本类的成员方法开机
        Mouse mouse = new Mouse();
        noteBook.useUSB(mouse);//传了一个mouse对象给接口实现类Mouse
        System.out.println("==================");
        KeyBoard keyBoard = new KeyBoard();
        noteBook.useUSB(keyBoard);

        noteBook.stop();
    }
}

object类

1)使用object接收所有类

class Person {}
class Student {}
public class Test {
    public static void main(String[] args) {
        Object per = new Person();
        Object stu = new Student();
    }
}

2)object类的结构图

下面我们一个个方法进行分析，看这些方法到底有什么作用：

1. clone()

        保护方法，实现对象的浅复制，只有实现了Cloneable 接口才可以调用该方法，否则抛出 CloneNotSupportedException 异常。

2. getClass()

        final方法，返回 Class 类型的对象，反射来获取对象。

3. toString()

        该方法用得比较多，一般子类都有覆盖，来获取对象的信息。

4. finalize()

        该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5. equals()

        比较对象的内容是否相等

6. hashCode()

        该方法用于哈希查找，重写了equals 方法一般都要重写 hashCode 方法。这个方法在一些具有哈希功能 的 Collection 中用到。

7. wait()

        wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。 wait() 方法一直等待，直到获得锁或者被中断。 wait(long timeout) 设定一个超时间隔，如果在规定时间 内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

        其他线程调用了该对象的notify 方法。

        其他线程调用了该对象的notifyAll 方法。

        其他线程调用了interrupt 中断该线程。

时间间隔到了。 此时该线程就可以被调度了，

如果是被中断的话就抛出一个InterruptedException异常。

8. notify() 该方法唤醒在该对象上等待的某个线程。

9. notifyAll()

该方法唤醒在该对象上等待的所有线程。

 3）object类的常用方法

        （1）toString方法