面向对象

1.类：模板，⽤来定义⼀类对象的⽅法和属性，⽐如⼈、学⽣、猫，万物都是有模板，都是可 以定义为类。 (类名⾸字⺟⼤写)

class Student{

}
class Person{

}
class Cat{

}

对象：类的实例化，⽐如 学⽣这个类实例化，就是 XX同学

Student student = new Student();
Cat cat1 = new Cat();
new Persion();

方法：⽅法是语句的集合，在⼀起完成⼀个功能

　　⽅法包含于类或对象中，即普通⽅法或者类⽅法

修饰符 返回值类型 ⽅法名(参数类型 参数名){
 ...
 ⽅法体
 ...
 return 返回值;
}

继承：⼦类继承⽗类的特征和⾏为，使得⼦类对象具有⽗类的⽅法和属性

　　⽗类也叫基类，具有公共的⽅法和属性

　　　　动物<-猫

　　　　动物<-狗

多态

　　同⼀个⾏为具有多个不同表现形式的能⼒

　　优点：减少耦合、灵活可拓展

　　⼀般是继承类或者重写⽅法实现

抽象

　　关键词abstract声明的类叫作抽象类，abstract声明的⽅法叫抽象⽅法

　　⼀个类⾥包含了⼀个或多个抽象⽅法，类就必须指定成抽象类

　　抽象⽅法属于⼀种特殊⽅法，只含有⼀个声明，没有⽅法体

teacher类

package day3;

public class Teacher {

    private int age;

    private String name;

    private int sex;

    public void tech(){
        System.out.println("教学");
    }

    public void sleep(){
        System.out.println("睡觉");
    }
}

school类

package day3;

public class School {

    private String name;

    private String address;

    private int age;

    private Teacher [] teachers;

    public void addTearcher(){

    }

    public void setTeachers(Teacher[] teachers){
        this.teachers = teachers;
    }

    public Teacher[] getTeachers() {
        return teachers;
    }

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

    public String getName(){
        return name;
    }

    public void setAge(int age){
        if(age>0){
            this.age = age;
            System.out.println("设置完成");
        }else{
            System.out.println("非法参数");
        }

    }

    public static void main(String [] args){
        System.out.println("主入口");
        School school = new School();
        school.setAge(1);
        Teacher teacher1 = new Teacher();
        teacher1.tech();
    }

}

2.构造函数:⼀种特殊的⽅法，创建对象时⽤来初始化对象，每次使⽤new 创建对象的时候，就会使⽤构造函数。与类具有相同的名称，但是没有返回值，Java会⾃动为每个类提供⼀个默认构造函数，如果⾃⼰定义了构造函数，就不再使⽤默认构造函数，如果没有显示的写出默认构造函数， 则会消失。

注意点：如果构造函数之间互相调⽤，务必写在⽅法第⼀⾏

构造函数种类

默认构造函数

public 类名(){
}

⽆参构造函数

public 类名(){
//写⾃定义的语句
}

有参构造函数

public 类名(参数类型1 参数名1，参数类型2 参数名2...){
//⾃定义⽅法体
}

构造函数的修饰符

　　public ⽤的最多，⽤来创建对象

　　private 私有化构造函数，不给外部创建对象，⽐如⼯具类，或者单例设计模式

　　default 默认的话，只能在当前包⾥⾯使⽤new 创建对象，⼏乎不⽤

user 类

package day3;
//一个类里面可以有多个构造函数
public class User {

    private int age;

    private String name;

//    构造函数，相当于这个对象初始化
//    如果构造函数之间互相调用，务必写在方法第一行
    public User(){
        System.out.println("这是默认构造函数");
        this.age = age;

    }

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

    public void setAge(int age){
        if(age>0){
            this.age = age;
        }else{
            System.out.println("非法参数");
        }
    }

    public int getAge(){
        return age;
    }

    public String getName(){
        return name;
    }

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

    public void sleep(){
        System.out.println("睡觉");
        String name = this.getName();
        System.out.println(name+"在睡觉");
    }

    public void sleep(String address){
        System.out.println(address);
        System.out.println("睡觉");
    }
}

maintest类

package day3;

public class MainTest {
    public static void main(String [] args){
//        test1();
//        test2();
        test3();
    }

    public static void test3(){
        User user = new User();
    }

    public static void test2(){
        String name = "一把手";
        int age = 5;

        User u = new User(name,age);
        User u2 = new User();
        System.out.println(u.getName());
    }

    public static void test1(){
        User user = new User();
        user.setAge(10);
        System.out.println(user.getAge());
        user.setName("大爷灰");
        System.out.println(user.getName());
    }
}

3.封装

　　封装是把过程和数据包围起来，对数据的访问只能通过已定义的接⼝即⽅法

　　在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在⼀起，封装定义程序如何引⽤对象的数据，封装实际上使⽤⽅法将类的数据隐藏起来，控制⽤户对类的修改和访问数据的程度。 适当的 封装可以让代码更容易理解和维护，也加强了代码的安全性.

　　类封装

　　⽅法封装

overload（重载，过载）

　　在⼀个类⾥⾯，⽅法名字相同，⽽参数不同，和返回类型⽆关

override（重写，覆盖）

　　⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写, 返回值和形参都不能改变

　　　　返回值类型，⽅法名，参数类型以及个数

　　⼦类能够根据需要实现⽗类的⽅法

3.this关键字

　　当⼀个对象创建后，JVM会给这个对象分配⼀个引⽤⾃身的指针，这个指针的名字就是 this

　　只能⽤于⾮静态⽅法体内，静态⽅法和代码块不能出现this

　　this就是指向当前对象本身

使⽤场景：

　　this(参数类型1 参数名，...) 表示当前类对应的构造函数

　　⽅法形参和对象的属性重名，⽤this来区分

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

4，继承

　　⼦类继承⽗类的特征和⾏为，使得⼦类对象具有⽗类的⽅法和属性

　　⽗类也叫基类，具有公共的⽅法和属性，⽣活中的例⼦

　　　　动物<-猫

　　　　动物<-狗

　　java中的继承，减少重复代码

　　格式，通过extends关键字

class ⽗类名称{

}
class ⼦类名称 extends ⽗类名称{

}

特点

　　⼦类拥有⽗类的⾮private的属性和⽅法

　　⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法 override(重写，覆盖)

　　实现了代码的复⽤

　　重写从⽗类那⾥继承来的⽅法的，当调⽤⽅法时候会优先调⽤⼦类的⽅法（默认就近原则）

注意：

　　不⽀持多继承，⽀持多重继承，多重继承提⾼了耦合性，组合优于继承

　　所有的类都是继承于 java.lang.Object

　　final关键字

　　　　修饰的类，则这个类不可以被继承

　　　　修饰⽅法，则这个⽅法不允许被覆盖（重写）

living类

package day3;

public class Living {

    public void run(){
        System.out.println("运动");
    }
}

animal类

package day3;

public class Animal extends Living{

    private String name;

    private int 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 void sleep(){
        System.out.println("闭着眼睛睡觉");
    }
}

dog类

package day3;

public class Dog extends Animal{

    public void eat(){
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep(){
        System.out.println("狗白天不着眼睛睡觉");
    }

    public void test(){
    //调用父类的方法,super表示父对象的引用
    super.sleep();
    //调用当前类的方法，this表示当前对象的引用
    this.sleep();
    }
}

EetendsMainTest类

package day3;

public class EetendsMainTest {
    public static void main(String [] args){
        Dog dog = new Dog();
        dog.setAge(1);
        dog.setName("旺财");
        System.out.println(dog.getAge());
        dog.sleep();
        dog.eat();
        dog.test();
    }
}

5.继承

　　⼀个引⽤变量，⽤于引⽤⽗类对象

　　⽗类和⼦类都具有相同的命名⽅法，要调⽤⽗类⽅法时使⽤

　　⽗类和⼦类都具有相同的命名属性，要调⽤⽗类中的属性时使⽤

　　super也是⽗类的构造函数，格式 super(参数)

　　注意点 调⽤super() 必须是类构造函数中的第⼀条语句，否则编译不通过

注意

　　每个⼦类构造⽅法的第⼀条语句，都是隐含地调⽤super()，如果⽗类没有这种形式的构造函 数，那么在编译的时候就会报错

public class Father {
 public Father(){
 System.out.println("father ⽆参构造函数");
 }
}
public class Children extends Father{
 public Children(){
 //默认存在，写和不写都⾏
 super();
 System.out.println("Child⽆参构造函数");
 }
}

　　this()和super()都指的是对象，均不可以在static环境中使⽤

　　包括：static变量,static⽅法，static语句块。

构造函数 super和this

　　this 和super在构造函数中只能有⼀个，且都必须是构造函数当中的第⼀⾏

　　当⽗类的构造函数是⽆参构造函数时，在⼦类的构造函数中，不⽤显式super()去调⽤⽗类的 构造函数,

　　当⽗类的构造函数是有参构造函数时，如果⼦类的构造函数中不写super()进⾏调⽤⽗类的构造函数，编译器会报错。

java继承后类的初始化顺序

　　问题：静态代码块、⾮静态代码、⽗类/⼦类⽆参构造⽅法、⽗类/⼦类的⼀般⽅法

father类

package day3;

public class Father {

    static {
        System.out.println("父类静态代码块");
    }

    public Father(){
        System.out.println("father 无参构造函数");
    }

    public Father(int age){
        System.out.println("father 有参构造函数");
    }

    public void sleep(){
        System.out.println("father sleep方法");
    }
}

children类

package day3;

public class Children extends Father{

    static {
        System.out.println("Child静态模块");
    }

    public Children(){
        System.out.println("Child 无参构造函数");
        super.sleep();
    }

    public void sleep(){
        System.out.println("Child sleep方法");
    }

}

SuperTest类

package day3;

public class SuperTest {
    public static void main(String [] args){
        new Children().sleep();
    }
}

6.抽象

　　需求：动物都有年龄和名称，但是吃的不⼀样，⽺吃草，⽼⻁吃⾁，但是都是闭着眼睛睡觉的

　　　　   ⻋，都有名称和价格，也有跑的⽅法，但是最⾼速度或者动⼒来源不⼀样

　　当⽗类的某些⽅法不确定时，可以⽤abstract关键字来修饰该⽅法，即抽象⽅法，⽤abstract 来修饰该类，即抽象类

　　抽象类将事物的共性的东⻄提取出来，由⼦类继承去实现，代码易扩展、易维护

　　java中的抽象类和抽象⽅法

//抽象类
abstract class 类名{
}
//抽象⽅法，不能有⽅法主体
abstract 返回类型 ⽅法名();

Vehicle类

package day4;

public abstract class Vehicle {

    public abstract void run();

    public void stop(){
        System.out.println("停在路上");
    }
}

Bicycle类

package day4;

public class Bicycle extends Vehicle{

    @Override
    public void run() {
        System.out.println("人力驱动");
    }
}

Auto类

package day4;

public class Auto extends Vehicle {

    @Override
    public void run() {
        System.out.println("汽油驱动");
    }
}

AbstractTest类

package day4;

public class AbstractTest {

    public static void main(String [] args){
        Bicycle bicycle = new Bicycle();
        Auto auto = new Auto();

        bicycle.run();
        bicycle.stop();

        auto.run();
        auto.stop();

//        不能 new 抽象类
//        new Vehicle();
    }
}

抽象特点：

　　抽象类的特点

　　　　抽象类不能被实例化，因为抽象类中⽅法未具体化，这是⼀种不完整的类，所以不能直 接实例化，编译⽆法通过

　　　　抽象类中不⼀定包含抽象⽅法，但是有抽象⽅法的类必定是抽象类

　　　　如果⼀个抽象类中可以没有抽象⽅法，这样做的⽬的是为了此类不能被实例化。

　　　　抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现，否则⼦类也是抽象类，需要⽤ abstract声明

　　　　抽象类不能使⽤final关键字修饰，因为final修饰的类是⽆法被继承

　　抽象⽅法的特点

　　　　抽象类中的抽象⽅法只是声明，不包含⽅法体

　　　　抽象⽅法不能⽤private修饰，因为抽象⽅法必须被⼦类实现（覆写），⽽private权限 对于⼦类来 说是不能访问的

　　　　⼀个类继承了⼀个抽象类，那么它必须全部覆写抽象类中的抽象⽅法，当然也可以不全 部覆写，如果 不覆写全部抽象⽅法则这个⼦类也必须是抽象类

　　构造⽅法，类⽅法（即static 修饰的⽅法）不能声明为抽象⽅法

7.接口

　　是抽象⽅法的集合，接⼝通常以interface来声明，⼀个类通过继承接⼝的⽅式，从⽽来继承 接⼝的抽象⽅法

　　语法

interface 名称 [extends 其他的接⼝名] {
 // 声明变量
 // 抽象⽅法
 int getMoney();
}

接⼝的特点

　　接⼝的⽅法都是抽象⽅法，默认都是 public abstract，其他修饰符都会报错

　　接⼝中可以含有变量，但是接⼝中的变量会被隐式的指定为 **public static final**

　　类描述对象的属性和⽅法，⽽接⼝则包含类要实现的⽅法

　　接⼝⽆法被实例化，需要被实现才⾏

　　⼀个实现接⼝的类，必须实现接⼝内所描述的所有⽅法，否则就必须声明为抽象类

接⼝和类的区别

　　接⼝没有构造函数

　　接⼝⾥可以有静态⽅法和⽅法体

　　接⼝中所有的⽅法必须是抽象⽅法（JDK8之后就不是）

　　接⼝不是被类继承了，⽽是要被类实现

　　接⼝⽀持多继承, 类不⽀持多个类继承

接⼝的实现implements

　　当类实现接⼝的时候，类要实现接⼝中所有的⽅法，不然类必须声明为抽象的类，使⽤ implements关键字实现所有接⼝

语法

class 类名 implements 接⼝名称[, 其他接⼝名称, 其他接⼝名称]{
 //要实现的⽅法
}

注意

　　⼀个类只能继承⼀个类，但是能实现多个接⼝

　　接⼝能继承另⼀个接⼝，接⼝的继承使⽤extends关键字，和类继承⼀样

JDK8新特性

　　interface中可以有static⽅法，但必须有⽅法实现体，该⽅法只属于该接⼝，接⼝名直接调⽤ 该⽅法

　　接⼝中新增default关键字修饰的⽅法，default⽅法只能定义在接⼝中，可以在⼦类或⼦接⼝ 中被重写

　　default定义的⽅法必须有⽅法体

　　⽗接⼝的default⽅法如果在⼦接⼝或⼦类被重写，那么⼦接⼝实现对象、⼦类对象，调⽤该 ⽅法，以重写为准

　　本类、接⼝如果没有重写⽗类（即接⼝）的default⽅法，则在调⽤default⽅法时，使⽤⽗类 定义的default⽅法逻辑

IPay类

package day4;

public interface IPay {

//    static 修饰符定义静态方法
    static void staticMethod() {
        System.out.println("接口中的静态方法");
    }

//    default 修饰符定义默认方法，默认方法不是抽象方法，可以重写也可以不重写
    default void defaultMethod() {
        System.out.println("接口中的默认方法");
    }
}

Alipay类

package day4;

public class Alipay implements IPay {

    @Override
    public void defaultMethod() {
        System.out.println("重写后的方法");
    }
}

interfaceTest类

package day4;

public class interfaceTest {

    public static void main(String [] args){

        IPay.staticMethod();
        Alipay alipay = new Alipay();
        alipay.defaultMethod();
    }
}

8.面向对象编程之InstanceOf关键词和多态

InstanceOf 关键词：是Java的⼀个⼆元操作符（运算符）,也是Java的保留关键字

作用：判断⼀个类是否实现了某个接⼝，或者判断⼀个实例对象是否属于⼀个类

语法

//如果该object 是该class的⼀个实例，那么返回true。如果该object 不是该class的⼀个实例，或者object是null，则返回false

boolean result = object instanceof class

参数：
　　result ：boolean类型。
　　object ：必选项。任意对象表达式。
　　class：必选项。任意已定义的对象类。

对象类型强制转换前的判断

Person p1 = new Student();
//判断对象p是否为Student类的实例
if(1p instanceof Student)
{
 //向下转型
 Student s = (Student)p1;
}

⽅法重写和重载

⽅法重写 overriede:⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写,

注意点

　　返回值和形参都不能改变

　　⽗类的成员⽅法只能被它的⼦类重写

　　final 和 static的⽅法不能被重写

　　构造⽅法不能被重写

　　访问权限不能⽐⽗类中被重写的⽅法的访问权限更低

⽅法重载 overload

　　⼀个类⾥⾯，⽅法名字相同但参数不同，返回类型可以相同也可以不同

　　⽐如构造函数重载

注意核⼼区分

override是在不同类之间的⾏为，overload是在同⼀个类中的⾏为

总结：Java多态

　　同⼀个⾏为具有多个不同表现形式或形态的能⼒

常⻅的⽅式：继承⽅法重写、同类⽅法重载、抽象⽅法、接⼝

10.写个计算器，能完成加减乘除运算

　　定义接⼝做参数

　　加减乘除定义4个类

　　定义⼀个静态⼯具类，把下⾯的接⼝作为其中⼀个形参对象，传递具体的运算符类完成计算

ICompute类

package day4;

//计算机接口
public interface ICompute {
    /**
     * 通过传递两个参数，完成传递
     * @param num1
     * @param num2
     * @return
     */
    int computer(int num1, int num2);
}

AddOper类

package day4;

public class AddOper implements ICompute {
    @Override
    public int computer(int num1, int num2) {
        return num1 + num2;
    }
}

SubOper类

package day4;

public class SubOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        return num1 - num2;
    }
}

MulOper类

package day4;

public class MulOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        return num1*num2;
    }
}

DeviceOper类

package day4;

public class DeviceOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        try {
            return num1/num2;
        }catch (Exception e){
            e.printStackTrace();
        }
        return -1;
    }
}

UseComputer类

package day4;

public class UseComputer {

    public static void computer(ICompute compute, int num1, int num2){
        int result = compute.computer(num1, num2);
        System.out.println(result);
    }
    public static void main(String [] args){
        UseComputer.computer(new AddOper(),25,5);
        UseComputer.computer(new SubOper(),25,5);
        UseComputer.computer(new MulOper(),25,5);
        UseComputer.computer(new DeviceOper(),25,0);
    }

}