Java面向对象

封装 继承 多态

多态 动态编译类型 增加可扩展性

一个对象的实际类型是确定的

//可指向的引用类型就不确定了;父类的引用指向子类
Student stu = new Student();
Person  stu2 = new Student();
Object stu3 = new Student();

当子类重写了父类的方法,执行子类的方法

对象能执行哪些方法,主要看左边的类型,和右边关系不大

对象能调用的方法都是自己的或者是父类的

父类性可以指向子类,但是不能调用子类独有的方法

多态注意事项

1. 多态是方法的多态,属性没有多态

2. 父类和子类,有联系. 类型转换异常(ClassCastException)

3. 存在条件:继承关系,方法需要重写.

   //父类引用指向子类对象!
   Father f1 = new Son();
   
   //下面这写些方法不能重写
   //static 方法,属于类,不许实例
   //final 常量;
   //private 方法;
   

Instanceof

两边有关系才能比较

		//关系树
		//Object > String
        //Object > Person > Student
        //Object > Person > Teacher
		//比较对象是Student;
        Object object = new Student();
        System.out.println(object instanceof Student);//ture
        System.out.println(object instanceof Person);//ture
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof Object);//ture
        System.out.println(object instanceof String);//false
        System.out.println("===========================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//ture
        System.out.println(person instanceof Person);//ture
        System.out.println(person instanceof Teacher);//false
        System.out.println(person instanceof Object);//ture
        //System.out.println(person instanceof String);//编译报错!
        System.out.println("===========================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//ture
        System.out.println(student instanceof Person);//ture
        System.out.println(student instanceof Object);//ture
        //System.out.println(student instanceof Teacher);//编译报错!
        //System.out.println(student instanceof String);//编译报错!

当父类想要调用子类方法时需要将父类强行转换为子类

//父类调用子类方法的格式
((Son)father).方法名;

子类转换为父类时,可能会丢失一些方法

多态总结

1. 父类引用指向子类的对象
2. 把子类转换为父类,向上转型
3. 把父类转换为子类,向下转换,强制转换
4. 方便方法的调用,减少重复代码!简介

Static

静态属性的使用方法

? 直接使用对象名调用属性.相当于默认属性为静态属性

同一类中

非静态方法可直接访问类中静态方法

静态方法可以直接调用静态方法

静态方法不能直接调用非静态方法

因为类加载机制

静态代码块

package com.yu.Oop.Demo07;

public class Person {
    //运行顺序      
    {
        System.out.println("匿名代码块");
    }//2 作用赋初值
    static{
        System.out.println("静态代码块");
    }//1 只执行一次

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

    public static void main(String[] args) {
        Person person = new Person();

    }
}



运行结果com.yu.Oop.Demo07.Person
静态代码块
匿名代码块
构造方法

mathematics 数学

Math.random() 在0-1之间产生一个随机数

//静态导入包
import static java.lang.Math.random;
//下次调用可直接使用random() 输出一个随机数
//不用经过Math函数调用

抽象类(abstract)

• abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类.
• 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类
• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的
• 抽象 方法,只有方法的声明,没有方法的实现,它是用来让子类实现的
• 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类

限制

1. 不能new这个抽象类,只能靠子类去实现它:约束!

2. 抽象类中可以写普通的方法

3. 抽象方法必须在抽象类中

   抽象的抽象:约束

问题

1. 抽象类存在构造器吗

抽象类中是存在构造器的
原因：

对于一个抽象类Person，一个继承了抽象类Person的子类Student，

可以定义一个抽象类的变量p，p只能引用非抽象子类Student中的对象。

Person p = new Student("Vince Vu", "Economics");
1
在子类Student中通过super()调用抽象类Person中的构造方法。
原文链接

2. 抽象类存在的意义

   在面向对象方法中，抽象类主要用来进行类型隐藏。构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。

接口(interface)

实现多继承

接口定义的属性都是常量(一般不用)

命名规则

接口类名加Impl

与其他类的区别

• 普通类:只有具体实现
• 抽象类:具体实现和规范(抽象方法)都有!
• 接口:只有规范!

实现接口类类就必须实现接口的方法

作用

1. 约束
2. 定义一些方法,让不同的人实现
3. 方法都是 public abstract
4. 接口常量 public abstract final
5. 接口不能被实例换,接口没有构造方法
6. implements 可以实现多个接口
7. 必须重写接口中的方法

内部类

定义

? 内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就成为内部类,而A类相对于B类来说就是一个外部类了

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

通过内部类可以获得外部类的私有属性

一个Java类中可以有多个class类但是只能有一个public class类