Java类及类的成员：属性、方法、构造器；代码块、内部类

面向对象的大特征：封装性、继承性、多态性、(抽象性)

属性

属性 vs 局部变量不同点：

1 在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2 关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected --->封装性
目前，大家声明属性时，都使用缺省就可以了。
局部变量：不可以使用权限修饰符。

3 默认初始化值的情况：
属性：类的属性，根据其类型，都默认初始化值。
整型（byte、short、int、long：0）
浮点型（float、double：0.0）
字符型（char：0 （或‘\u0000‘））
布尔型（boolean：false）

引用数据类型（类、数组、接口：null）

局部变量：没默认初始化值。
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。

4 在内存中加载的位置：
属性：加载到堆空间中 （非static）
局部变量：加载到栈空间

方法

java值传递机制：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

重写与重写：

重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

　　　　同一个类、相同方法名参数列表不同：参数个数不同，参数类型不同

　　　　（可变个数形参的方法

　　　　　　　　形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。

　　　　　　　　可变个数形参在方法的形参中，必须声明在末尾

　　　　　　　　可变个数形参在方法的形参中,最多只能声明一个可变形参。

     public void show(int i){
        
    }
    
    public void show(String s){
        System.out.println("show(String)");
    }
    
    public void show(String ... strs){
        System.out.println("show(String ... strs)");
        
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
    //不能与上一个方法同时存在
//    public void show(String[] strs){
//        
//    }
调用时：
        test.show("hello");
        test.show("hello","world");
        test.show();
        
        test.show(new String[]{"AA","BB","CC"});

　　　　　　）

重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

（子类不能重写父类中声明为private权限的方法）

返回值类型：
* >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
* >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类

子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

构造器

1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器。

代码块与内部类

代码块的作用：用来初始化类、对象的信息

静态代码块：
>内部可以输出语句
>随着类的加载而执行,而且只执行一次
>作用：初始化类的信息
>如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
>静态代码块的执行要优先于非静态代码块的执行
>静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：
>内部可以输出语句
>随着对象的创建而执行
>每创建一个对象，就执行一次非静态代码块
>作用：可以在创建对象时，对对象的属性等进行初始化
>如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
>非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

内部类：调用外部类的结构，可以被static修饰，可以被4种不同的权限修饰

　　内部类创建：

//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();

//创建非静态的Bird内部类的实例(非静态的成员内部类):
Person p = new Person();
Person.Bird bird = p.new Bird();

封装性

为什么要引入封装性？

• 我们程序设计追求“高内聚，低耦合”。

　　　　高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；

　　　　低耦合 ：仅对外暴露少量的方法用于使用。

• 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

权限从小到大顺序为：private < 缺省 < protected < public

继承性

为什么要有类的继承性？(继承性的好处）

① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提

一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
特别的，父类中声明为 private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已

多态性

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

Java面向对象（四）

原文：https://www.cnblogs.com/opuntiaa/p/14802174.html