面向对象编程19

1.instanceof和类型转换

package com.oop;

import com.oop.Demo06.Student;
import com.oop.Demo06.Person;
import com.oop.Demo06.Teacher;

//一个项目应该只存在一个main方法
public class Application {
    //Student->Person->Object
    //Teacher->Person->Object
    //String—>Object
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);// true
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);// false
        System.out.println("______________________________________________");
        Person person = new Student();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);// true
        System.out.println(person instanceof Teacher);// false
       // System.out.println(person instanceof String);// 编译报错
        System.out.println("______________________________________________");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);// true
       // System.out.println(student instanceof Teacher);// 编译报错
       // System.out.println(student instanceof String);// 编译报错
        System.out.println("______________________________________________");
    }
}

2.static关键字详解

package com.oop.Demo07;

public class Student {
    {//可用于赋初值
        //代码块（匿名代码块）->创建对象时自动创建，构造器之前。
        System.out.println("代码块（匿名代码块）");
    }

    static{
        //static静态代码块->类一旦加载，它就执行，无论新建多少个对象，它永久只执行一次，且在构造器之前。
        System.out.println("static静态代码块");
    }

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

    public static void main(String[] args) {
        Student student = new Student();
    }

    //执行顺序如下
    //1.static静态代码块
    //2.代码块（匿名代码块）
    //3.构造方法
}

类可以直接调用static静态属性和方法，对象只能调用非静态属性和方法。

静态的属性和方法是和类一起加载的所以不用创建对象即可直接调用，main方也是static静态方法。

一个类一旦被final修饰后，它将不能够被继承。

静态导入包

package com.oop.Demo07;
//静态导入包：例中可直接使用random(),PI
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Person {
    public static void main(String[] args) {
        System.out.println(random());//Math.random();
    }
}

3.抽象类

抽象类特点：
1.不能new这个抽象类，只能依靠子类去实现：约束！
2.抽象方法必须在抽象类中，而抽象类中可以自由写普通方法。
3.抽象的抽象：约束~

类是单继承，接口可多继承

要想继承abstract抽象类，继承的类就必须重写它的方法，除非这个类本身就是abstract抽象类（可由它的子类来完成这个步骤）

package com.oop.Demo08;
//abstract抽象类  //类是单继承，接口可多继承
public abstract class Action {
    //约束 有人帮我们实现
    //abstract 抽象方法，只有方法名，没有方法的实现。
    public abstract void doSomething();
    //抽象类特点：
    //    1.不能new这个抽象类，只能依靠子类去实现：约束！
    //    2.抽象方法必须在抽象类中，而抽象类中可以自由写普通方法。
    //    3.抽象的抽象：约束~

    //抽象类存在构造器吗？ 有构造器
    //存在的意义：抽象出来共有的部分，然后提高开发效率


}

package com.oop.Demo08;
//要想继承abstract抽象类，继承的类就必须重写它的方法，除非这个类本身就是abstract抽象类（可由它的子类来完成这个步骤）
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

4.接口的定义与实现

普通类：只有具体的实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范！自己无法写方法。->专业的约束！ 约束的实现和分离：面向接口编程~

接口的本质是契约，就和我们的法律法规一样，制定好之后大家去遵守。

OO(面向对象)的精髓，就是对对象的抽象，最能体现这一点的就是接口。声明接口的关键字是interface。

package com.oop.Demo09;
//interface 接口都需要有实现类
public interface UserService {
    //接口中所有的定义其实都是抽象的：public abstract
    public abstract void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.oop.Demo09;

public  interface TimeService {
    //常量 public static final
    int AGE = 99;
    void timer();
}

package com.oop.Demo09;
//抽象类：extends->单继承
//类 可以实现接口 implements
//实现了接口的类就需要重写接口中的方法。

import java.sql.Time;

//多继承，利用接口实现多继承
public class UserServiceImpL implements UserService, TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }


    //ctrl+i 自动生成
}

package com.oop.Demo09;
//抽象类：extends->单继承
//类 可以实现接口 implements
//实现了接口的类就需要重写接口中的方法。

import java.sql.Time;

//多继承，利用接口实现多继承
public class UserServiceImpL implements UserService, TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }


    //ctrl+i 自动生成
}

作用：

​ 1.约束

​ 2.定义一些方法，让不同的人实现~ 10个员工完成–>1份工作

​ 3.方法默认：public absract

​ 4.常量默认：public static final

​ 5.接口不能被实例化，接口没有构造方法

​ 6.implements可以实现多个接口 ，实现接口必须要重写接口中的方法

5.N种内部类

1.成员内部类

package com.oop.Demo10;

public class Outer {
    private  final int A = 2;
    public void speak(){
        System.out.println("外部类说话");
    }
    public class Inner{
        public void speak(){
            System.out.println("内部类说话");
        }
        public void getA(){
            System.out.println("A的值是："+A);
        }
    }
}

package com.oop;


import com.oop.Demo10.Outer;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.speak();
        Outer.Inner inner = outer.new Inner();
        inner.speak();
        inner.getA();
    }
}

2.静态内部类

​ 同成员内部类，加关键词 static，进而也就无法得到外部类Outer的私有属性A了。

3.匿名内部类

4.局部内部类

…等等