Day07----面向对象

面向对象编程

（Java的核心思想就是OOP）

1. 初识面向对象

2. 方法回顾与加深

静态方法可以通过类名.方法名跨类调用，非静态方法只能实例化一个类，也就是新建一个对象去调用public的类

package com.kang.OOP;
//引用传递：对象，本质还是值传递
public class Demo011 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//输出NULL
        Demo011.changPersonName(person);//会修改到person这个指针指向的内存中name的区域，所以会修改对象的属性值
        System.out.println(person.name);//输出啦啦啦
    }
    public static void changPersonName(Person person){
        person.name="啦啦啦";
    }
}
//只能有一个public类
class Person{
    String name;  //默认为NULL

}

3. 对象的创建分析

注意：

1. **构造器可以理解为C++中的构造函数，分为有参构造和无参构造，如果定义了有参构造但是想使用无参构造会报错，所以默认留下一个无参构造，有参构造的那个相当于方法的重载**

2. 通过`alt+insert`可以快速生成有参和无参的构造器

​

4. 面向对象三大特性

封装

封装性的意义：1. 提高程序的安全性，保护数据；2. 隐藏代码的实现细节；3. 统一接口，系统可维护性增加

继承

ctrl+H可以快速打开继承树

在Java中都默认继承object类

1. super和this相对，super指向父类，但是私有的东西由于无法被继承所以在子类中使用super也无法调用父类中的私有方法 其他调用如this.name；supr.name

2. super()调用父类的构造；调用父类的构造器必须要在子类构造器的第一行，this()调用本类的构造也必须在第一行，所以它们两不能同时用
3. 如果父类没有无参构造，子类也无法进行无参构造，所以要写个有参构造，一定要留着一个无参构造

重写必须有继承关系，子类重写父类，方法体不同;只能重写方法，方法名相同，参数也相同;修饰符可以被扩大但是不能被缩小，public>protected>default>private; 抛出的异常的范围可以被缩小但是不能被扩大；

为什么需要重写？父类的功能子类不一定需要或者说子类不一定满足

多态

多态就是同一个接口，使用不同的实例而执行不同操作

static方法属于类的方法不属于对象，final常量，private方法都不能被重写

instanceof：

​ 用于判断一个类是什么类型

instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：

boolean result = obj instanceof Class

其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。看obj和class之间有没有父子关系。

int i = 0;
System.out.println(i instanceof Integer);//编译不通过
System.out.println(i instanceof Object); //编译不通过

instanceof 运算符只能用作对象的判断。

System.out.println( null instanceof Object);``//false

类型转换

1. 父类换成子类属于高转低，向下转型，强制转换
2. 子类转换成父类，向上转型，可能丢失自己的本来的一些方法，最简单的就是父类的引用指向子类的对象。

package com.kang.OOP;
//一个项目应该只有一个main方法
public class Demo02 {
    public static void main(String[] args){
        Sub s = new Sub();
        System.out.println(s.count);//20
        s.display();
        Base b = s;
        System.out.println(b == s);//true
        System.out.println(b.count);//10
        b.display();
    }
}
class Base {
    int count = 10;
    public void display() {
        System.out.println(this.count);
    }
}

class Sub extends Base {
    int count = 20;
    public void display() {
        System.out.println(this.count);
    }
}

子类继承父类
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。

对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

static关键字

public class Demo03 {
    private static int age;  //静态变量   多线程！
    private double score;//非静态的变量


    public void run(){

    }
    public static void go(){

    }
    public static void main(String[] args) {
    go();
    }
}

public class Demo04 {
   //赋初始值
    {
        System.out.println("匿名代码块"); //代码块（匿名代码块），一般也不建议这样写
    }//是在对象创建时初始化

    static{

        System.out.println("静态代码块");//静态代码块（匿名代码块），一般也不建议这样写
    }//类一加载就执行，永久只执行一次

    public Demo04() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        //输出结果：静态代码块、匿名代码块、构造方法
        Demo04 demo05 = new Demo04();
        //输出结果：匿名代码块、构造方法
    }
}

//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(random());
        System.out.println(PI);
        //被final修饰的类不能被继承
    }
}

5. 抽象类和接口

抽象类

//抽象类
public abstract class Action {
    //约束~有人帮我们实现。
//abstract，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类去实现宫：约束！
    //2.抽象类中可以与普通的方法了
    //3.抽象方法必须在抽象类
}

//抽象类的子类都必须实现它的抽象方法，抽象子类可以不用
//java的类是单继承extends，但是接口可以多继承
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

public interface UserService {
//接口中所有定义的方法都默认是public abstract
    //接口里定义的常量默认是public static final
    int age =99;
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

//类可以通过implements
//实现了接口的类必须实现接口中的方法
public class UserServiceImpl implements UserService{
//鼠标放在爆红的地方，alt+enter
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

6. 内部类以及OOP实战

内部类