Java——面向对象（static关键字开始）

一、static

可以修饰成员变量和成员方法

关键字特点：

　　随着类的加载而加载；

　　优先于对象存在；

　　被类的所有对象共享；

　　可以通过类名直接调用；

注意事项：

　　在静态方法中是没有this关键字的

　　静态的方法只能访问静态的成员变量和成员方法

　　静态的成员，是属于类本身的东西，是优先于对象而存在的

静态的内容存在于方法区的静态区

静态变量和成员变量的区

所属不同

　　静态变量属于类，所以也称为类变量

　　成员变量属于对象，所以也称为实例变量

内存中位置不同

　　静态变量存储于方法区的静态区

　　成员变量存储于堆内存

内存出现时间不同

　　静态变量随着类的加载而加载，随着类的消失而消失

　　成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同

　　静态变量可以通过类名调用，也可以通过对象调用

　　成员变量只能通过类名调用

二、帮助文档

如何使用

1.找到文档，打开文档

2，点击索引，搜查要查询的类

3. 看在哪个包下，但凡不在java.lang包下的都需要进行导包

4.查看继承和实现关系

4，看这个类的结构

　　看这个类的成员变量

　　看这个类的构造方法

　　看这个类的成员方法

（如果一个类没有构造方法，意味着这个类是一个工具类。特点：变量或者方法都是被static修饰）

三、代码块

顾名思意就是使用{}括起来的代码，叫做代码块，根据其定义的位置和语句格式不同，分为4种代码块：
局部代码块：定义在方法内部的代码块，叫做局部代码块，局部代码块之间的执行顺序是根据定义的上下顺序来的
构造代码快：定义在类中方法外，写的格式与局部代码块的一样，在创建对象的时候被执行，优先于构造方法执行，与构造方法的顺序无关
静态代码块：定义在类中方法外的，格式是需要使用static关键字进行修饰，只会在程序运行之前执行一次，后面不会再执行
同步代码块

四、继承

概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可

通过extends可以实现类与类的继承

　　class 子类名 extends 父类名{}

单独的这个类可以成为父类，基类或者超类；这多个类可以称为子类或者派生类

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的继承上，还可以定义自己的成员。

好处

　　提高了代码的复用性：多个类的相同成员可以放到同一个类中

　　提高了代码的维护性：如果功能的代码需要修改，修改一处即可

　　让类与类之间产生了关系，是多态的前提：这也是继承的一个弊端，类的耦合性很强

特点(注意事项)

1、java中的类与类之间不能进行多继承，只能进行单继承，但是可以进行多层继承，形成继承体系
2、子类只能继承父类中所有非私有的成员（成员变量和成员方法）
3、子类无法继承父类中的构造方法，但是要想初始化子类，必须先初始化父类（指的是执行一次父类中任意一个构造方法）
4、不要为了部分功能去使用继承
5、什么时候使用继承？满足英语中的 is a的关系

继承中成员变量的关系（就近原则）

在子类方法中访问一个变量

首先在子类局部范围找

然后在子类成员范围找

最后在父类成员范围找

如果都没找到就报错

this和super的异同之处

　　相同：使用语句都相似

　　　　访问成员变量：this.成员变量  super.成员变量

　　　　访问成员方法： this.成员方法(...)    super.成员方法(...)

　　　　访问构造方法：this(...)   super(...)

　　不同：this代表的是当前类的对象   super代表的是直接父类的引用

继承中构造方法的关系

　　子类通过super去显示调用父类其他的带参的构造方法

　　子类通过this其调用本类的其他构造方法

　　　　（本类的其他构造方法也必须首先访问了父类的构造）

　　一定要注意

　　　　　super(...)或者this(...)必须出现在第一条语句上

　　　　　否则就会有父类数据的多次初始化

继承中成员方法的关系

方法的重写：在继承关系中，子类的方法的声明（返回值类型，方法名，参数列表）与父类的声明都一样，只是实现不一样，这样的现象叫做方法的重写

　　　　　　判断一个方法能不能重写，可以在方法的上边加上一个注解@override，如果加上不报错，就说明可以重写

面试题：重写与重载的区别？Override与Overload的区别？
方法的重写：在继承关系中，子类中的方法的声明（返回值类型，方法名，参数列表）与父类中的方法声明都一样，只是实现不一样，这样的现象，叫做方法的重写。
方法的重载：在同一个类中，方法的方法名相同，参数列表不同，这个现象叫做方法的重载，与返回值无关。

重写的注意事项：

　　1.父类中私有的方法不能被重写，因为私有的方法子类根本不能继承

　　2.子类重写父类方法时，权限不能更低，推荐除了特殊要求外，子类重写父类的方法要保持一致

　　　　顺序：public protected 默认 private

　　3.父类静态方法，子类无法重写

final关键字

可以修饰类，成员变量，成员方法

修饰类，类不能被继承

修饰变量，变量就变成了常量

修饰方法，方法不能被重写

final修饰局部变量

　　在方法内部，该变量不可以被改变

　　在方法声明上，基本类型是值不能被改变

　　　　　　　　　　引用数据类型是地址值不能被改变

　　final修饰变量的初始化时机：在对象构造完毕前即可

五、多态

概述

某一个事物，在不同时刻表现出来的不同的状态

前提

有继承关系

有方法重写

有父类引用指向子类对象

多态访问成员特点

成员变量

　　编译看左边，运行看左边

成员方法

　　编译看左边，运行看右边

静态方法

　　编译看左边，运行也看左边

好处

提高了程序的维护性（由继承保证）

提高了程序的扩展性（由多态保证）

弊端

无法使用子类特有的成员方法

多态的转型问题

向上转型

　　从子到父

　　父类引用指向子类子类对象

向下转型

　　从父到子

　　父类引用转为子类对象

六、抽象类

概述

一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

抽象类不是具体的类，关键词abstract

可以修饰类和方法

特点

必须用abstract关键词修饰  格式：abstract class 类名{}

　　　　　　　　　　　　　　　public abstract void eat（）

抽象类不一定有抽象方法，但有抽象方法的类一定是抽象类

抽象类不能实例化

　　所以如果想实例化的话，要按照多态的形式，有具体的子类实例化。其实这也是多态的一种，抽象类多态

抽象类的子类，要么是抽象类，要么重写抽象类中的所有抽象方法

注意事项

1.修饰方法的时候，方便变为抽象方法，不能有具体的实现，连大括号都不能有

2.当抽象类继承抽象类的时候，可以不用重写抽象方法，也可以选择重写方法

成员特点

成员变量

　　可以是变量

　　也可以是常量

构造方法

　　有构造方法，但不能实例化

　　构造方法的作用：用于子类访问父类数据的初始化

成员方法

　　可以使抽象方法，限定子类必须完成某些动作

　　也可以有非抽象方法 ，提高代码服用性

一个类没有抽象方法，也可以被定为抽象类

abstract不能和哪些关键词共存

　　不能与private关键字共存

　　不能与static共存

　　不能与final共存

七、接口

概述

为了体现事物功能的扩至性，提供了接口来定以额外的功能

可以将接口看作是一个特殊的类，因为接口也会被编译成一个class文件　

特点

用关键词interface表示

　　interface 接口名{}

类实现接口用implements表示

　　格式：class 类名 implements 接口名{}

接口不能实例化

　　如何实例化：按照多态的方式，由具体的子类实例化。其实也是多态的一种，接口多态。

接口的子类

　　要么是抽象类

　　要么重写接口中的所有抽象方法　　

成员特点

　　　　成员变量：接口中只允许定义常量，默认存在修饰符 public static final

　　　　构造方法：接口中不存在构造方法，不能进行实例化

　　　　成员方法：接口中只允许定义抽象方法，方法会默认添加修饰符 public abstract　

注意事项

　　类和接口的关系是实现关系

　　具体的类实现一个接口的时候，必须要实现接口中所有抽象方法

类与类，类与接口，接口与接口之间的关系

类与类：存在继承关系，只能单继承，不能多继承，但可以多层继承，形成继承体系

类与接口：存在实现关系，implements，可以一次性实现多个接口

接口与接口：存在继承关系，可以存在多继承

抽象类和接口的区别

成员区别

抽象类：变量，常量；有抽象方法；抽象方法，非抽象方法

接口：常量；抽象方法

设计理念区别

抽象类：被继承体现的是：“is a”的关系。共性功能。

接口：被实现体现的是：“like a”的关系。扩展功能。

八、形式参数和返回值问题

形式参数类型的问题

基本数据类型：当基本数据类型作为方法的参数类型的时候，将来调用时传入的是具体的值

引用数据类型：
　　　　数组：当数组为方法的参数类型的时候，将来调用时传入的是数组的地址值
　　　　类：当你看到一个类作为方法的参数类型的时候，将来调用时需要传入该类或者该类的子类对象
　　　　抽象类：当你看到抽象类作为方法的形式参数类型的时候，将来调用时需要传入具体的子类对象
　　　　接口：当你看到接口作为方法的形式参数类型的时候，将来调用时需要传入实现该接口的具体子类的对象

当类作为方法的参数类型：

当抽象类作为方法的形式参数类型：

当接口作为方法的形式参数类型

返回值类型的问题

基本数据类型：当基本数据类型作为方法的返回值类型的时候，将来方法返回的是具体的值

引用数据类型：
　　　　数组：当数组为方法的返回值的时候，将来方法返回的是数组的地址值

　　　　类：当你看到一个方法的返回值类型是一个类的时候，方法内部应该返回该类的对象或者该类的子类对象

　　　　抽象类：当你看到一个方法返回值类型是一个抽象类的时候，方法内部应该返回该抽象类的具体实现子类对象

　　　　接口：当你看到一个方法返回值类型是一个接口的时候，方法内部应该返回实现该接口的具体子类对象

方法的返回值类型是一个类：

方法的返回值类型是一个抽象类：

方法的返回值类型是一个接口：

九、包

概述

其实就是文件夹

作用：对类进行分类管理

基本划分：按照功能划分或者按照角色划分

定义及注意事项

格式

　　package 包名；

注意事项

　　package语句必须是程序的第一条可执行代码

　　package语句在一个java文件中只能有一个

　　如果没有package，默认表示无包名

导包格式

　　import 包名；

　　注意：

　　　　这种方式导入是到类的名称　　

　　　　虽然最后可以写*，但是不建议

十、权限修饰符

类及其组成可以用的修饰符：

十一、内部类

概述

将类定义在一个类里边

根据定义位置的不同，分为两种内部类

　　1.成员内部类（将类定义在类中成员位置上）

　　2.局部内部类（将类定义在类中成员方法内部）

访问特点

　　内部类可以直接访问外部类的成员，包括私有

　　外部类要访问内部类的成员，必须创建对象

成员内部类

　　创建对象

　　外部类名.内部类名 对象名 = 外部类对象.内部类对象

成员内部的常见修饰符

　　private 为了保证数据的安全性

　　 static 为了让数据访问更方便

　　　　被静态修饰的成员内部类只能访问外部类的静态成员

　　　　内部类被静态修饰后的方法、

　　　　　　静态方法

　　　　　　非静态方法

面试题

局部内部类

　　可以直接访问外部类的成员

　　可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

　　局部内部类访问局部变量的注意事项：

　　　　必须被final修饰

　　　　因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。

　　　　为了让数据还能继续被使用，就用final修饰。这样在堆内存中存储的其实是一个常量值。

十二、匿名内部类

没有名字的内部类

匿名内部类的定义格式

　　new 类名/抽象类名/接口名(){

　　　　重写方法

　　}

前提：存在一个类或者接口

　　　　这里的类可以是具体类也可以是抽象类

本质：是一个继承了类或者实现了接口的子类匿名对象　　

匿名内部类的第二种用法：将匿名内部类作为返回值返回i

nterface Inter2{

void show();

}

class Inter2Demo{
    public Inter2 fun(){
        //使用匿名内部类改写
        return new Inter2() {
            @Override
            public void show() {
                System.out.println("");
            }
        };
    }
}

public class NIMingInnerClassDemo2 {
    public static void main(String[] args) {
        Inter2Demo inter2Demo = new Inter2Demo();
        Inter2 inter2 = inter2Demo.fun();
        inter2.show();
    }
}

面试题