面向对象

这些你都会了吗？来小试牛刀看看~

1. 在Java中定义一个不做事且没有参数的构造方法的作用?
2.构造器Constructor是否可被override?
3.重载和重写的区别?

想知道答案就往下拉~

面向过程

强调步骤，当需要实现一个功能的时候，每一个具体步骤都要亲力亲为，详细处理每一个细节。

面向对象

强调对象，当需要实现一个功能的时候，不关心估计的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

面向对象的三个大基本特征

- 封装

封装就是将一些细节信息隐藏起来，对于外界不可见。
封装在Java中的体现
1.方法就是一种封装。
2.关键字private也是一种封装。
一旦使用private进行修饰，那么本来中仍然可以随意访问。
但是！超出了本类范围之外就不能再直接访问了。
间接访问private成员变量，就是定义一对儿Getter/Setter方法。
必须叫setXxx或者是getXxx命名规则。
对于GetXxx来说，不能有参数，返回值类型和成员变量对应。
对于SetXxx来说，不能有返回值，参数类型和成员变量对应。
对于基本类型当中的boolean值来说，Getter方法一定要写成isXxx形式，而Setter规则不变。

- 继承

继承时多态的前提，如果没有继承，就没有多态。
继承主要解决的问题是——共性抽取。
父类（基类、超类）
子类（派生类）
继承关系当中的特点

• 子类可以拥有父类的“内容”。
• 子类还可以拥有自己专有的内容。
  在继承关系中——”子类就是一个父类“，也就是说，子类可以当作父类看待。
  例如父类是员工，子类是讲师，那么讲师就是一个员工。关系——is-a。
  在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方法。
• 直接通过子类对象访问成员变量—— 等号左边是谁，就优先用谁，没有则向上找。
• 间接通过成员方法访问成员变量——该方法属于谁，就优先用谁，没有则向上找。
  区别子类方法中重名的三种
  局部变量—————直接写成员变量名
  本类的成员变量——this.成员变量名
  父类的成员变量——super.成员变量名
  在父子类的继承关系中，创建子类对象，访问成员方法的规则
  创建的对象是谁，就优先用谁，如果没有则向上找。
  注意事项
  无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
  重写（Override）
  概念
  在继承关系当中，方法的名称一样，参数列表也一样。
  重写（Override）——方法的名称一样，参数列表【也一样】。覆盖、复写。
  重载（Overload）——方法的名称一样，参数列表【不一样】。
  方法的覆盖重写特点
  创建的是子类对象，则优先用用子类方法。
  注意事项
  1.必须保证父子类之间方法的名称相同，参数列表也相同。
  @Override——写在方法前面，用来检测是不是有效的正确覆盖重写。
  这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
  2.子类方法的返回值必须【小于等】一父类方法的返回值范围。
  小扩展提示——java.lang. Object类是所有类的公共最高父类(祖宗类），java.lang. String就是Object的子类。
  3.子类方法的权限修饰符必须【大于等】于父类的方法权限修饰符。
  小扩展提示——public> protected> (default)> private
  备注：(default)不是关键字default，而是什么都不写，留空。
  继承中，父子类构造方法的访问特点

1. 子类构造方法当中有一个默认隐含“的super（）”调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类的重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
4. 子类必须调用父类的构造方法，不写则赠送super（）；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

super关键字的三种用法

1.在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造变量。
this关键字的三种用法
1.在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
在第三种用法中要注意
A.this（…）调用也必须是构造方法的第一个语句，唯一一个。
B.super和this两种构造调用，不能同时使用。

super与this关键字图解

Java继承的三个特点

- 多态

多态的格式与使用

代码中体现多态性，其中就是一句话——父类引用指向子类对象。
格式
父类名称 对象名 = new 子类名称（）；
或者
接口名称 对象名 = new 实现类名称（）；
在多态代码中
成员变量口诀——编译看左边，运行还看左边。
成员方法口诀——编译看左边，运行看右边。

多态的好处

对象的转型

如何才能知道一个父类引用的对象，本来是什么子类？
格式
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例。

笔记本USB接口案例

public interface USB {
    public abstract void open();//打开设备
    public abstract void close();//关闭设备
}

public class Computer {
    public void powerOn() {
        System.out.println("笔记本电脑开机");
    }

    public void powerOff() {
        System.out.println("笔记本电脑关机");
    }

    //使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb) {
        usb.open();//打开设备
        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;//向下转型
            mouse.click();

        } else if (usb instanceof Keyboard) {
            Keyboard keyboard = (Keyboard) usb;//向下转型
            keyboard.type();
        }
        usb.close();//关闭设备
    }
}

//鼠标就是一个USB设备
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

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

//键盘就是一个USB设备
public class Keyboard implements USB{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }

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

    }
    public void type(){
        System.out.println("键盘输入");
    }
}

public class DemoMain {
    public static void main(String[] args) {
        //首先创建一个笔记本
        Computer computer = new Computer();
        computer.powerOn();
        //准备一个鼠标，供电脑使用
//        Mouse mouse=new Mouse();
        //首先进行向上转型
        USB usbMouse = new Mouse();
//参数是USB类型，我正好传递进去的就是USB鼠标
        computer.useDevice(usbMouse);

        //创建一个USB键盘
        Keyboard keyboard =new Keyboard();//没有使用多态写法
        //方法参数是USB类型，传递进去的是实现类对象
        computer.useDevice(keyboard);//正确写法！也发生了向上转型
        //使用子类对象，匿名对象，也可以
        computer.useDevice((new Keyboard()));//也是正确写法！
        computer.powerOff();

    }

}

类

是一组相关属性和行为的集合。
属性
就是该事务的状态信息。
行为
就是该事务能够做什么。
类与对象的关系

• 类是对一类事物的描述，是抽象的。
• 对象是一类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。
  注意事项
• 成员变量是直接定义在类当中，在方法外边。
• 成员方法不要写static
  通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
  1.导包
  也就是指出需要使用的类，在什么位置。
  import 报名称.类名称；
  对于和当前类属于同一个包的情况，可以省略导包语句不写。
  2.创建，格式
  类名称 对象名 = new 类名称（）；
  3.使用，分为两种情况
  使用成员变量：对象名.成员变量名。
  使用成员方法：对象名.成员方法（参数）。
  注意事项
  成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

【答案在这里】
1.字符型常量和字符串常量的区别
字符型常量和字符串常量的区别
形式上: 字符常量是单引号引起的一个字符 字符串常量是双引号引起的若干个字符
含义上: 字符常量相当于一个整形值(ASCII值),可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)
占内存大小上: 字符常量只占一个字节 字符串常量占若干个字节(至少一个字符结束标志)　
2.构造器Constructor是否可被override
在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承，所以Constructor也就不能被override,但是可以overload,所以你可以看到一个类中有多个构造函数的情况。
3.重载和重写的区别
重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。

怎么样，答对了吗？