Day05-面向对象-对象4

多态

• 即同一个方法可以根据发送对象的不同而采用不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

• 多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态性。

public class Person {

    public void run(){
        System.out.println("run");
    }
}
/*
  public static void main(String[] args) {
    //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类型引用指向子类型对象

        //Student 能调用的方法都是自己的或继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，只要看对象左边的类型，和右边的关系不大
        ((Student) s2).eat();//子类重写了父亲的方法，执行子类的方法
        s1.eat();
    }
 */
/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastExcption!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
    1.static 方法，属于类，它不属于实例
    2.final 常量；
    3.private 方法；
 */

public class Student extends Person{

    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

• instanceof （类型转换） 引用类型，判断一个对象是什么类

public static void main(String[] args) {

    //Object>String
    //Object>Person>Teacher
    //Object>Person>Student
    Object object = new Student();
    //System.out.println(x instanceof y);//能不能编译通过 要看x和y有没有父子关系

    System.out.println(object instanceof Student);//true
    System.out.println(object instanceof Person);//true
    System.out.println(object instanceof Object);//true
    System.out.println(object instanceof Teacher);//false
    System.out.println(object instanceof String);//false
    System.out.println("-------------------------------");
    Person person = new Student();
    System.out.println(person instanceof Student);//true
    System.out.println(person instanceof Person);//true
    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);//true
    System.out.println(student instanceof Person);//true
    System.out.println(student instanceof Object);//true
    //System.out.println(student instanceof Teacher);//编译报错
    //System.out.println(student instanceof String);//编译报错

}

public class Application {
    public static void main(String[] args) {

        //子类转换为父类，可能会都是自己本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;
    }
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型。
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用 ，减少重复的代码

封装，继承，多态    抽象类，接口
 */

public class Teacher extends Person {
}

public class Person {

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

}

public class Student extends Person{

    public void go(){
        System.out.println("go");
    }
}

• static

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

    public void run(){

    }
    public static void go(){

    }

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

public class Person {        //2  赋初始值        {            System.out.println("匿名代码块");        }        //1 只执行一次        static {            System.out.println("静态代码块");        }        //3        public Person(){            System.out.println("构造方法");        }    public static void main(String[] args) {        Person person = new Person();        System.out.println("----------------");        Person person1 = new Person();    }}

//静态导入包import static java.lang.Math.PI;import static java.lang.Math.random;public class Test {    public static void main(String[] args) {        System.out.println(random());        System.out.println(PI);    }}

抽象类

• abstaract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，name该方法就是抽象方法；如果用来修饰类，name该类就是抽象类。

• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

• 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

• 子类继承抽象类，那么就必须实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

  //抽象类的所有方法，继承了它的子类，都必须要实现它的方法 除非子类也是抽象类public class A extends Action {    @Override    public void doSomething() {    }}
  

package com.Oop.dome08;//abstract  抽象类：类 extends ： 单继承  （接口可以多继承）public abstract class Action {        //约束  有人帮我们实现        //abstract,抽象方法 只有方法名字，没有方法的实现。    public abstract void doSomething();    // 1. 不能new这个抽象类，只能靠子类去实现它；约束！    //2.抽象类可以写普通方法    //3.抽象方法必须在抽象类中    //抽象的抽象： 约束}

接口

• 普通类：只有具体实现

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

• 接口：只有规范！自己无法写方法_{专业的约束！约束和实现分离：面向接口编程}.

• **接口的本质是契约，**就像我们人间的法律一样。制定好后大家都遵守。

• OO（面向对象）的精髓是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对了具备抽象能力的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

• 声明类的关键字是class，声明接口的关键字是interface

• 接口的作用：

  • 约束
  • 定义一些方法，让不同的人实现 ~ 10个人---->实现一个接口
  • public abstract
  • public static final
  • 接口不能被实例化,接口中没有构造方法
  • implements可以实现多个接口
  • 必须重写接口的方法

接口：UserService

//抽象的思维~ //interface  定义的关键字   接口都需要有实现类public interface UserService {   //常量 ~public static final    int AGE = 99;    //接口中的所有定义的方法其实都是抽象的 public abstract    // void run(String name);    void add();    void delete();    void update();    void query();    }

接口：TimeService

public interface TimeService {    void timer();}

实现类：UserServiceImpl

//抽象类: extends//类 可以实现接口 implements  接口// 实现了接口的类，就需要重写接口中的方法//多继承~利用接口实现多继承public class UserServiceImpl implements UserService,TimeService{    @Override    public void add() {    }    @Override    public void delete() {    }    @Override    public void update() {    }    @Override    public void query() {    }    @Override    public void timer() {    }}

内部类

• 内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

  1. 成员内部类

  2. 静态内部类

  3. 局部内部类

  4. 匿名内部类

public class Outer {    private int  id = 10;    public void outer(){        System.out.println("这是外部类的方法");    }    public class Inner{        public void in(){            System.out.println("这是内部类的方法");        }        public void GetId(){            System.out.println(id);        }    }}

public class Application {    public static void main(String[] args) {        Outer outer = new Outer();        //通过这个外部类来实例化内部类        Outer.Inner inner = outer.new Inner();        inner.GetId();    }}