Java面向对象常见关键字解释

用于定义类，函数，变量修饰符的关键字

static

1，static：静态的
2，static可以用来修饰：属性，方法，代码块，内部类
3，使用static修饰属性 ：静态变量（类变量）
相较于实例变量的区别：①随着类的加载而加载，
②早于对象的创建
③只要权限允许，可以通过“对象.属性”的方式调用，存在于方法区的静态域
4， 属性：按是否使用static修饰，又分为： 静态属性 vs 非静态属性（实例变量）
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个对像中的非静态属性时，不会导致其他对象中同样属性值的修改

                 静态变量：我们创建了类的多个对象，多个对象共享一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过的

5， static修饰属性的其他说明：
①静态变量随着类的加载而加载，可以直接通过类.属性（静态变量）的方式直接调用
②静态变量加载要早于对象的创建
③由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中

             ④          类变量 （static）           实例变量（非static）
                    类         yes                         no
                  对象        yes                       yes
                         即:不能通过类取调用实例变量

6，使用static修饰方法 ：静态方法
①随着类的加载而加载，直接通过“类.静态方法”来调用方法
② 静态方法 非静态方法
类 yes no
对象 yes yes
即不能通过类来调用非静态的方法

         ③静态方法中只能调用静态的方法或属性
            非静态的方法中，既可以调用非静态的属性或方法，也可以调用静态的属性或方法

7，static注意点：
5.1在静态的方法内，不能使用this关键字，super关键字
5.2关于静态属性和静态方法的调用，大家都从生命周期的角度去理解

,判断属性和方法是否应该static的经验之谈：

①开发中，如何确定一个属性是否要声明为static：

 >属性是可以被多个对象所共享的，不会随着对象不同而不同的
  >类中的常量也常常声明为static的

②开发中，如何确定一个方法是否要声明为static

 >操作静态属性的方法，通常设置为static
  >工具类中的方法，习惯上声明为static的，比如：Math，Arrays，Collections

final

1，final可以用来修饰：类，方法，变量

2，final用来修饰一个类，此类就不能被其他类继承

           比如;String类，System类，StringBuffer类

3，final修饰一个方法：表明此方法不可以再被重写

           比如：Object类中的getClass

4，final用来修饰变量：此时的“变量”称为常量
5，final修饰属性，可以考虑赋值的位置有：
①显示初始化
②代码块里赋值，final为非静态的，代码块也只能是非静态的
③构造器赋值（另类的一种动态赋值），不同的构造器得重新赋值，即每个构造器都得被赋值
注：修饰属性时，不可以在方法内进行赋值
原因：构造器调完之后，对象就出现了，属性就被加载，在堆空间中就出现值了，通过对象调方法只是对此值 进行修改，而常量不能被修改，方法进行太迟了
6，final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量，当我们调用此方法时，给常量形参赋一个实参， 一旦以后，就只能在方法体内使用此形参，但不能进行重新赋值
7,static final 用来修饰属性：全局常量（大写）

abstract

1，abstract：抽象的
2，abstract可以用来修饰的结构：类，方法
3，abstract修饰类：抽象类（抽象类能实现接口，抽象类可以继承非抽象的类，后者反之成立）
①此类不能实例化，即不能造对象（一般去提供子类，让子类实例化）
②抽象类中一定有构造器，便于子类对象实例化时使用（涉及子类对象的全过程）
③开发中，都会提供抽象类的子类，让子类对象实例化

4，abstract修饰方法：抽象方法
格式：public abstract void eat（）；
①抽象方法只有方法的声明，没有方法体
②包含抽象方法的类一定是一个抽象类，即无法通过造对象，来调用方法的，反之，抽象类中可以没有抽象方法
③若子类重写了父类（间接父类也算）中所有的抽象方法以后，此子类方可实例化（即造对象），若没有全部重写，则此子类也一定是一个抽象类

用于定义类与类之间关系的关键字

extends

继承性的格式： class A extends B{}
A:子类，派生类，subclass
B；父类，超类，基类，superclass

体现：2.1，一旦子类A继承父类 B以后，子类A中就继承了父类B声明的结构 ，属性，方法 特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构，只因为封装性的影响，使得子类不能直接不能直接调用父类的结构而已
2.2，子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的的拓展子类和父类的关系，不同于子类和集合的关系
Java中关于继承性的规定：
1，一个类可以被多个子类继承
2，Java的单继承性：一个类只能有一个父类
3，子父类是相对的概念
4，子类直接继承的父类，称为直接父类，间接继承的父类称为：间接父类
5，子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

implements

Java开发中，通过类去实现（implements）的方式来使用接口

用于定义建立实例及引用实例，判断实例的关键字

super

1，super理解为：父类的
2，super可以用来调用：属性，方法，构造器
3，super的使用：
3.1我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显示的调用父类中声明的属性或方法，但是通常情况下，我们习惯省略“super.”
3.2特殊情况：当子类和和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须是显示使用“super.属性”的方式，表明调用的是父类中声明的属性，不写的话则调用的是子类中重写后的方法
3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显示的是使用“super.方法”的方式，表明调用的是父类中声明的属性
4，super调用构造器
4.1，我们可以在子类的构造器中显示的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器，“this”（形参列表）调用的是本类中的构造器
4.2 “super（形参列表）”的使用，必须声明在子类构造器的首行
4.3 我们在类的构造器中，针对于“this（形参列表）"或“super（形参列表）”只能二选一，不能同时出现
4.4 在构造器的首行，没有显示的声明“this（形参列表）”或“super（形参列表）”，则默认调用的是父类中空参的构造器，super（空参）
4.5在类的多个构造器中，至少有一个类的构造器中使用了“super（形参列表）”调用父类中的构造器

this

1，this调用属性和方法
2，this关键字的使用：
①this可以用来修饰：属性，方法，构造器
②this修饰属性和方法
this理解为：当前对象或正在创建的对象
2.1， 在类的方法中，我们可以使用“this.属性”或“this.方法”的方式调用正在创建的对象属性，但是通常情况下，我们都选择省略“this.”。特殊情况下如果方法的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参

2.2，在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式调用正在创建的对象属性，但是通常情况下，我们都选择省略“this.”。特殊情况下如果方法的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参。
类如：pubilc Person(String name){
this.name = name;
}
public Person(int age){
this.age = age;
}

3，this调用构造器
①我们在类的构造器中，可以显示的使用“this（形参列表）”方式，调用本类中其他的构造器
②构造器中不能通过“this（形参列表）”方式调用自己，只能调别的
③如果一个类中有n个构造器其，最多有n-1个使用了“this（形参列表）”方式，即只能向一个方向调用，你调用它，它不能反过来调用你
④规定：“this（形参列表）”必须声明在当前构造器的首行
⑤构造器内部最多只能声明一个“this（形参列表）”方式来调用其他的构造器

说明：super和this关键字在首行的原因

无论通过哪个构造器创建子类对象，需要保证先初始化父类
   目的：当子类继承父类以后，“继承”父类中所有属性和方法，因此子类有必须要知道父类如何为对象进行初始化

instanceOf

**，instanceof（关键字）操作符引用：

主要用来判断是不是当前类的实例

1，不能调用子类所特有的方法，属性
2，有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明为父类类型，只能调用父类中声明的属性和方法
3，使用强转时，可能会出现ClassCastException异常
4，向下转型，使用强制类型转换
Man m1 = （Man）p2
// p2为自定义Person类型
Woman w1 = （Woman）p2；
w1.goShopping（）；

**，instanceof关键字的使用：

①a instanceof A：判断对象a是否是类A的实例，如果是，返回true，如果不是返回false
如：if（p2 instanceof Woman）{
Woman w1 = （Woman）p2；
w1.goShopping();
System.out.println(“类B是类A*woman***”)
}
使用情景：为了避免在向下转型时出现ClassCastException异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true就进行向下转型，否则不
②如果a instanceof A返回true，则a instanceof B也返回true，其中类B是类A的子类

**，向下转型：

原因：有了对象多态性以后，内存中实际上是加载了子类额特有的属性和方法，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用，，这时候需要用向下转型

使用：使用强制类型转换符

用于异常处理的关键字

try-catch-finally

一，
过程一:“抛”：程序正在执型的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出
一旦抛出对象以后，其后的代码就不在执行
过程二:“抓”：可以理解为异常的处理方式：①try-catch-finally ②throws

二：try-catch-finally
try{
//可能出现异常的代码
}catch（异常类型1 变量名1）{
//处理异常的方式1
}catch（异常类型2 变量名2）{
//处理异常的方式2
}catch（异常类型3 变量名3）{
//处理异常的方式3
…
finally{
//一定会执行的代码
}
说明：
1，finally是可选的
2，使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，据此对象的类型，去catch中进行匹配
3，一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理，就跳出当前的try-catch结构（此时是没有写finally的情况下）
4，catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓
catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面，否则一定报错
5，常用的异常处理的方式：①String getMessage（） ②printStackTrace（）
6，在try结构中声明的变量，再出了try结构以后，就不能被调用
7，try-catch-finally结构可以嵌套使用

体会：①使用try-catch-finally处理编译时异常，使得程序在编译时就不报错，但运行时仍可能报错，相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现
②由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally，针对编译时异常，我们一定要考虑异常的处理
三，finally的使用：
1，finally是可选的
2，finally声明的是一定会被执行的代码，即使catch中再次出现了异常，try中有return语句，catch中有return等情况
3，像数据库连接，输入输出流，网络编程Socket等资源，JVM是不能被自动回收的，我们需要手动的进行资源的释放，此时的资源释放，就需要声明在finally中

throws

1，“throws”+异常类型写在方法的声明处，指明此方法执行时，可能会抛出的异常类型
一旦方法体执行时，，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型是，就会被抛出，异常后续的代码就不在被执行
2，体会：try-catch-finally：真正的将异常给处理掉了
throws只是将异常抛给了方法的调用者，并没有真正的将异常处理掉
开发中如何选择try-catch-finally还是使用throws：
1，如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须是使用try-catch-finally方式处理
2，执行的方法a中，又先后调用了另外的几个方法，几个方法是递进关系执行的，我们建议这几个方法使用throws的方式进行处理，而执行的这方法a可以使用try-catch-finally处理

用于包的关键字

package

1，为了更好的实现项目中类的管理，提供包的概念
2，使用package声明类或者接口所属的包，身名在源文件的首行
3，包属于标识符，遵循标识符的命名规则，规范，“见名知意”
4，每"."一次，就代表一层文件目录

补充：同一个包下，不能命名同名的接口或类，不同的包下可以命名同名的接口或类

import

1，import：导入
2，在源文件中显式的使用import结构导入指定包下的类，接口
3，声明在package（包）的声明和类的声明之间
4，如果需要导入多个结构，则并列写出即可
5，举例格式：import java.util.*
6，可以使用“xxx.*”的方式，表示可以导入xxx包下所有的结构
7，如果使用的类或者接口是java.lang包下定义的，可以省略import结构
8，如果使用的类或接口是在本包下定义的，则也可以省略import接口
9，如果在源文件中使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示

10，如果使用“xxx.*”的方式表明可以调用xxx包下的所有结构，但如果使用的是xxx下子包下的类的话，仍需要导入
11，import static：导入指定类或接口中的静态结构：属性或者方法

用于定义数据类型的关键字

return

return关键字的使用：
①使用范围：使用在方法中
②作用：结束方法
针对有返回值类型的方法，使用“return 数据”方法返回所要的数据（有返回值得去接受）
③注意点：return关键字后面不可以声明执行语句

interface

1，接口使用interface来定义
2，java中，接口和类是并列的两个结构
3，如何定义接口，定义接口中的成员
3.1，JDK7及以前只能定义全局常量和抽象方法
>全局常量：public static final的，书写时，可以省略不写
>抽象方法：public abstract的
3.2，JDK8，除了定义全局常量和抽象方法以外，还可以定义静态方法，默认方法
4，接口中不能定义构造器，意味着接口不可以实例化
5，Java开发中，通过类去实现（implements）的方式来使用
如果类覆盖了接口中所有的抽象方法，则此类可以实现实例化
如果类没有覆盖了接口中所有的抽象方法，则此类仍然为一个抽象类
6，Java类可以实现多个接口，—>弥补了Java单继承性的局限性
格式：class AA extends implements CC,DD,EE{}