Java基础-面向对象下

面向对象的特征三：多态性

多态性: 一个事物的多种形态
对象的多态性: 父类的引用指向子类的对象(或子类的对象赋给父类的引用)
举例 man 和woman都继承了person
    Person p = new Man();
    Person p = new Woman();
√多态的使用:
    写法:
        父类  a = new 子类();
    编译期时，只能调用父类中声明的方法，在运行时，实际运行的是子类重写父类的方法
    也就是编译看左边，运行看右边
√多态的前提:
    1.要有继承关系
    2.方法重写
√    多态只适用于方法，不适用属性，属性(编译和运行都看左边)
√     多态性是运行时行为     
有了对象的多态性后，内存实际上加载了子类特有的属性和方法，但是由于变量声明为父类类型，所以编译时，只能调用父类中声明的属性和方法不能调用子类特有的属性和方法

子类特有的属性和方法:
    使用强制类型转换() ,向下转型
    使用强转时，可能会出异常
    可以使用instanceof 判断，如果是true就向下转型，false，不进行向下转型

instanceof关键字的使用

a  instanceof B 判断对象a 是否是B类的实例，是则true，不是则false
当A是B的子类时，对象a instanceof A 返回true ,那么 对象a instanceof B也是true
    a instanceof B 返回true时，a instanceof A 不一定是true;

可以理解成

假设 【小明的爸爸是小刚】小强寻亲记，找上门了。先和小明做了DNA检测，检测出来，小强的爸爸是小明，那么肯定，小强是小刚的孙子。

那如果说，小强先和小刚做DNA检测，检测出来是true，那小强和小明做检测，是不是不一定为true？有可能小强是小明的哥哥？弟弟？决不可能是小明的儿子。

Object类的使用

Object类是所有类的根父类
如果在类的声明中未使用extends关键字指明其父类则默认为java.lang.Object类
Object类中的功能(属性、方法)具有通用性
    属性:没有

常用方法

• equals()的使用

1.是一个方法，并非运算符
2.只适用于引用数据类型
3.Object类中equals的定义
    public boolean equals (Object obj){
        return (this == obj);
    }
    说明Object中的equals和==的功能是一样的，都是比较两个对象的地址值是否相同
4.String\Date\File、包装类等都重写了Object类中的equals方法，重写以后，比较的不是两个地址值是否相同而是比较的实体内容
5.通常情况下，如果自定义的类也需要equals方法，则可以重写object的equals方法

equals方法测试实例

public boolean equals(Object obj){
    if(obj == this){
        return true;
    }
    if(obj instanceof 类){
        //强转
        类 对象 = (类) obj;
        return this.属性1 == 对象.属性1
    }
    return false;
}
写法1 "John".equals(Person.getName());
写法2 Person.getName().equals("John");
这两种写法大致没有区别，但建议使用写法1，因为写法2 可能会出现空指针的情况

==运算符

==: 运算符
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果判断是基本数据类型，则比较两个变量的值是否相等
如果判断的是引用数据类型，则比较两个对象的地址值是否相等

==和equals()的区别

1.==是运算符，equals()是Object类的方法
    1.1使用== 判断基本类型，比较两个变量的值是否相同
    1.2判断引用类型，比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体
2.equals() 只适用于引用数据类型

toString()的使用

1.输入一个对象时，实际上就调用了当前对象的toString方法
2.String、date等类都重写了toString方法
3.输出自定义类，可以重写toString方法

重写toString()

public String toString(){
    return "类 [属性]"
}

重写hashCode()

public native int hashCode(); Object类中定义
自定义类重写hashCod方法，直接使用软件自动生成的

包装类

为了使基本数据类型的变量具有类的特征，从而引入包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型之间的转换

基本数据类型 <----> 包装类 ,自动装箱，与自动拆箱,类型要匹配
        装箱 Integer i = new Integer(12);
        拆箱 Integer.intValue();
基本数据类型、包装类 ---> String 调用String 重载的valueOf(xxx)
String ---> 基本数据类型、包装类:调用包装类的parseXxx(String s);

 static关键字

static : 静态的
1.可以用来修饰的结构；主要用来修饰类的内部结构
属性、方法、代码块、内部类
2.static修饰属性:静态变量(或类变量)
    属性: 是否使用static修饰，又分为:静态属性vs非静态属性(实例变量)
        实例变量:创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个对象的非静态属性时，不会导致其他对象的属性值的改变
        静态变量: 创建类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，其他对象的静态对象也会跟着改变
    注意:静态变量随着类的加载而加载.可以通过类.静态变量的方式进行调用
        静态变量的加载要早于对象的创建
        由于类只会加载一次，则静态变量在内存中也只会存在一份: 存在方法区的静态域中
    静态属性举例: System.out;Math.PI

static修饰方法

随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
静态方法中，只能调用静态的属性或方法
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

 static的注意点 ：在静态的方法内，不能使用this关键字，super关键字

什么时候使用static关键字

属性:
    当属性可被多个对象共享时，可以使用static，常量一般声明为static
方法:
    操作静态属性的方法,通常设置为static
    工具类中的方法，习惯上声明为static的，比如 Math\Arrays\Connections

4.代码块

类的成员之四：代码块(初始化块)

写法

        {

                //代码语句

        }

作用：用来初始化类，对象的信息

分类：代码块要是使用修饰符，只能使用static

        static{

                //代码语句

         }

静态代码块和非静态代码块的对比

	静态代码块	非静态代码块
内部是否可以输出语句	可以	可以
什么时候执行和执行次数	随着类的加载而执行，而且只执行一次	随着对象的创建而执行
作用	初始化	初始化
多个代码块执行顺序	若声明了多个静态代码块，则按照先后顺序执行且静态代码块优先与非静态代码块执行	若声明了多个非静态代码块，则按照先后顺序执行
支持调用什么	仅支持调用静态的属性和方法	静态和非静态的属性、方法都支持

final修饰符

1.可以用来修饰类、方法、变量
2.具体描述:
    final 用来修饰一个类:此类不能被其他类所继承
    final 用来修饰方法，表示该方法不可以被重写
    final 用来修饰属性必须赋值，且不能改值，必须在构造方法完成之前赋值操作
    static final 用来修饰全局常量
    赋值位置：显式初始化、代码块中初始化、构造器中初始化

abstract修饰符

1.可以用来修饰: 类、方法
2.具体描述:
    abstract 用来修饰一个类(抽象类) 此类不能被实例化，抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化的全过程) 都会提供抽象类的子类，让子类实例化，完成相关的操作
    abstract 用来修饰方法(抽象方法) 抽象的方法只有方法的声明，并没有方法体，包含抽象方法的类，一定是个抽象类，抽象类中可以没有抽象方法，若子类重写了父类中的所有抽象方法后，此子类可以实例化，若子类没有重写父类中的抽象方法，则子类也是抽象类，需要用abstract修饰
 3.注意:
    abstract 不能用来修饰:属性、构造器等结构
    abstract 不能用来修饰私有方法、静态方法、final方法、final类

interface关键字

1.接口使用interface定义
2.java中，接口和类是并列的两个结构
3.如何定义接口:定义接口中的成员
    3.1JDK7及以前:只能定义全局常量和抽象方法
        全局常量: public static final的，但是书写时，可以省略
        抽象方法: public abstract的
    3.2JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
        静态方法：public static void a(){}
                    接口中定义的静态方法，只能通过接口来调用
        默认方法: public default void b(){}
                通过实现类的对象，可以调用接口中的默认方法，如果实现类重写了接口中的默认方法，调用的是重写的方法，调用接口A中的默认方法 ，接口A.super.默认方法();
4.接口中不能定义构造器!意味着接口不可实例化
5.接口可以让类去实现(implements) 的方式来使用
    如果实现类覆盖了接口中的抽象方法，则此实现类就可以实例化
    如果实现类没覆盖接口中的抽象方法，则此实现类仍为一个抽象类
6.java类可以实现多个接口 ---> 弥补了java单继承的局限性
    格式: class A extends BB implements C,d,e
7.接口和接口之间可以继承，而且可以多继承
8.接口的具体使用:体现多态性
9.接口是一种规范
10如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，子类(或实现类)没有重写该方法，则默认调用父类的方法
11，如果实现类实现了多个接口，而多个接口中定义了同名同参数的默认方法
    在实现类么有重写的情况,会报错--> 接口冲突

5.内部类

内部类:类的第五个成员
1.java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2.内部类的分类:
    成员内部类(静态、非静态) vs 局部内部类(方法内、代码块内、构造器内)
3.成员内部类的理解
    一方面，作为外部类的成员
        调用外部类的结构
        可以被static修饰
        可以被4种不同的权限修饰
另一方面，作为一个类
    类内可以定义属性、方法、构造器等
    可以被final修饰，表示此类不能被继承。言外之意，不适用final，就可以被继承
    可以被abstract修饰
4.成员内部类:
    创建成员内部类的对象
    Person.Dog dog = new Person.Dog();
    创建非静态的Bird内部类的实例(非静态的成员内部类)
    Person p = new Person();
    Person.Bird bird = p.new Bird();

写法

class A{
            class B{
                非静态成员内部类    
            }
            static class C{
                静态成员内部类    
            }
            public void aa(){
                class D{
                    局部内部类
                }
            }

}

 

---

本人是Java初学者，水平有限，本文章中如果有不对的地方，麻烦您能指出来。向您表示感谢。