文章目录
一. 用于定义访问权限修饰的关键字（3个）
private
default（缺省）
protect
public
可用于修饰 类、方法、属性 ，可用于定义对象对该类、属性或者方法的访问权限
若是用以上的修饰符修饰后，类/方法/属性 的访问权限如下
| 修饰符 | 同一个类中 | 同一个包中 | 子类 | 所有类 |
|---|---|---|---|---|
| private | Y | N | N | N |
| default(缺省) | Y | Y | N | N |
| protect | Y | Y | Y | N |
| public | Y | Y | Y | Y |
二. 用于定义类、函数、变量修饰的关键字（4个）
abstract
final
static
synchronized
1. abstract
可用于修饰类、函数
- 用 abstract 修饰的类叫做抽象类：
- 所谓抽象类只是在普通方法的基础上，扩充了一些抽象方法。
- 注意：抽象类不能直接被实例化。
- 抽象类的子类必须覆写抽象类的所有抽象方法。
- 抽象类的对象可以通过对象多态性利用子类为其实例化。（向上转型）
- 用 abstract 修饰的方法叫做抽象方法：
- 抽象方法只是只实现而没有实现的方法（即没有方法体）。
- 在一个类中若是有抽象方法，则他所在的类一定也要用 abstract 定义，表示抽象类。
// 抽象类
abstract class Person{
private String name;
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
/**
* 一般 {} 中表示方法体，该方法为抽象方法，因此没有方法体
*/
public abstract void getInfo();
}
// 抽象类的子类
class Student extends Person{
public void getInfo(){
System.out.println("I am a student");
}
}
public class Main{
public static void main(String[] args){
Person per = new Student(); // 实例化子类，向上转型
per.getInfo();
}
}
2. final
- 修饰类：提高安全性，增加程序的可读性，用 final 修饰的类不能类继承。（如String，StringBuffer，System 等类）
- 修饰方法：用 final 修饰的方法不能被重写（覆写）（此处下去再理解重写/覆写和重载的区别）
- 修饰变量：被 final 修饰的变量近似可以理解为常量，即她它值不能改变，不能再给赋值。
/*
* 正确，因为final修饰的类，但++的却是其对象，说明类属性改变，类不一定跟着改变
*/
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
3. static
- 修饰属性：称为静态属性（类属性），在属性前加上 static 关键字即可
传统属性的特征：保存在堆内存中，且每个对象都独有一份该属性。
而类属性（即用static修饰的属性）保存在全局数据区的内存中，所有用该类创建的对象都可直接调用该区域内的属性，类似于全局变量。
类属性的特点：
- 在调用时使用，类名.属性名的方式调用。
- 类属性在对象没被创建时都可调用，而普通属性只能在对象创建后调用。
- 用 类名.属性名 = ？ 修改了类属性后，所有对象都要同步该值
在描述共享概念，或者全局的属性，并不受对象控制的属性时，即可用 static 修饰
- 修饰方法：可称为静态方法（类方法），在方法前加上修饰符 static
静态方法的特点：
- 通过类名.方法名的方式调用
- 静态方法中只能调用 静态属性 或者 静态方法
- 而普通方法中允许访问static 方法或者属性
- 静态方法 / 静态属性 在调用时不能用 this 调用，因为 this 指的是当前对象，而静态方法 / 静态属性 是属于类的存在。
4. synchronized
在用于确保线程安全，表明一段代码需要同步执行。
- 修饰 代码块：用 synchronized 修饰一段代码块，
- 这段代码块包裹的是，可能会发生线程安全问题的代码，即这段代码有对 同一属性进行写的操作
- 锁的是代码块中引用所指向的对象
- 修饰 普通方法：
- 锁的是 this 所指向的对象
- 修饰 静态方法：
- 方法所在 类 的锁
- synchronized(类名.class)
三. 用于定义类与类之间关系的关键字（2个）
extends
implements
前置知识：
- 什么是类？
答：类是具有相同属性或者行为的对象集合，简单来说，类就相当于一张蓝图或者说是模型图（自行车），在创建某个对象时，不用管这个对象内部是怎么的，就直接创建就行了 - 什么是对象？
答：对象是类的实例，一辆辆的自行车 - 什么是接口？
答：接口就是抽象方法和全局变量的结合，用 interface 关键字来定义
接口中的属性和方法只能是 public 权限，即便是不写访问权限，也是public
interface IMessage{
public static final String name = "My name is wpp"; // 全局变量
public abstract void Print(); // 抽象方法
}
- 面向对象的三大特征：
-
封装：就是把客观事物抽象成类的过程，而且在抽象的过程中，可以对对象的属性或者行为设置不一样的权限，以提高他们的安全性。
-
继承：继承是子类继承父类的所有属性和行为，并对这些行为进行扩展的一种关系。例如：羊是食草动物的一个实例，老虎是食肉动物的一个实例，而羊和老虎都是动物，具有动物这一大类的一些属性，例如吃、叫等等。
-
多态：多态就是一个类的实例对象关于某一个行为在不同的情况下有不同的表现形式。在Java中多态有两种表现形式：方法的多态性、对象的多态性。
- 方法的多态：（1）方法的重载：同一方法名称可以根据参数的类型或者个数不同，调用不同的方法体；（2）方法的覆写：同一父类的方法，可能根据实例化子类的不同有不同实现
- 对象的多态：（1）对象的向上转型：父类 父类实例 = new 子类(); （2）对象的向下转型：子类 子类实例 = (子类)new 父类();
-
1. extends
- 用于类与类之间的继承关系
- 类对抽象类的继承也用extends
- 一个类只能继承 一个类
2. implement
- 子类如果想要使用接口，就必须要用 implement 来实现接口
- 一个子类可以实现多个接口
- 【可以利用接口实现多继承的概念】对于接口的子类（不是抽象类），必须覆写接口中的全部抽象方法
- 可以通过实例化接口的子类（先是向上转型），然后通过向下转型，得到接口的实例化对象
四. 用于定义建立实例及引用实例，判断实例的关键字（4个）
new
this
super
instanceof
1. new
是一个运算符，用于创建引用类型的实例对象。
Person per = new Person("wpp",18);
在这句代码中，一个进行了三个部分：声明、申请空间（实例化）、初始化
- 声明一个变量来指向一个对象：Person per用来声明了一个 Person 类型的数据，名称为 per ，只是简单声明，并没有创建对象。
- 实例化一个对象：new 运算符通过调用类的构造方法，实例化一个对象，给这个对象分配内存并返回一个指向该对象的引用。
- 初始化一个类对象：通过调用构造方法，对类的实例数据赋初值。
2. this
访问本类中的属性和方法
- this 调用本类属性
这种情况一般用于类代码中，当类方法的参数与类的属性同名时，类中属性被无法正确赋值。此时要使用 this 关键字。
this.属性名 = 参数名
看以下代码：
class Person{
public String name;
public int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
}
只要在类的方法中访问类中的属性，一定要加 this 关键字。
- this 调用本类方法
this 调用本类方法时有以下两种情况
1.调用普通方法：this. 方法名称(参数);
2.调用构造方法：this.(参数)
this 调用普通方法
在本类中调用本类的方法时不加 this 也可正常调用，但最好还是加上（目的：在本类有继承的情况下，可以区分方法的定义来源于哪个类）
class Person{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
this.print();
}
public void print(){
System.out.println("------------------------");
}
}
this 调用构造方法
在Java中，构造方法的互相调用可用 this
注意：this 调用构造方法的语句必须放在构造方法的首行。
class Person{
private String name;
private int age;
public Person(){
System.out.println("********产⽣⼀个新的Person对象********");
}
public Person(String name){
System.out.println("********产⽣⼀个新的Person对象********");
this.name = name ;
}
public Person(String name,int age){
System.out.println("********产⽣⼀个新的Person对象********");
this.name = name ;
this.age = age ;
}
public String getPersonInfo(){
return "姓名：" + name + ",年龄："+age;
}
}
三个构造方法变形之后如下：
public Person(){
System.out.println("********产⽣⼀个新的Person对象********");
}
public Person(String name){
this();
this.name = name;
}
public Person(String name,int age){
this(name);
this.age = age;
}
- this 调用当前对象
class P{
public void Print(){
System.out.println("[PRINT 方法]" + this);
}
}
public class Main{
public static void main(String[] args){
P p1 = new P();
System.out.println("[MAIN 方法]" + p1);
p1.Print();
System.out.println("------------------");
P p2 = new P();
System.out.println("[MAIN 方法]" + p2);
p2.Print();
}
}
3. super
由子类访问父类中的属性、方法，方法是在对父方法重写的时候上保留一部分父方法。
用于调用父类的构造方法
直接使用 super(参数) 调用即可，但必须放到构造方法的首行
class Person{
public Person(){
System.out.println("父类产生的对象");
}
}
class Student extends Person{
public Student(){
super();
System.out.println("子类产生的对象");
}
}
用于调用父类的同名方法
调用方式：super.方法名(参数)，必须放在子类代码的首行
class Person{
public void print(){
System.out.println("I just a person");
}
}
class Student extends Person{
public void print(){
super.print();
System.out.println("I am a student");
}
}
public class Main{
public static void main(String[] args){
new Student().print();
}
}
用于调用父类的属性
使用方式：super.属性名
class Person{
String info = "小明";
}
class Student extends Person{
String info = "王盼盼";
public void print(){
System.out.println(super.info);
System.out.println(this.info);
}
}
public class Main{
public static void main(String[] args){
new Student().print();
}
}
4. instanceof
用来判断一个对象是否是某个指定类的实例，此处的指定类必须是该对象的类或者该对象类的子类（我自己理解为是该对象能否进行向上或向下转换的类），返回值为一个布尔值（若是该对象是这个特定类的实例或者可以通过向上转换得到的，则返回true，若该类是该对象的类通过向下转换得到的则返回false）。
使用方法：对象名称 instanceof 类名
五. 用于处理异常的关键字
try
catch
finally
throw
throws
异常：
其中，粉色部分属于受查异常：必须进行异常异常处理（利用try/catch/finally及时处理，或者用throws抛到上级方法（调用本方法的方法）中去处理），要不然代码会飘红，不能编译。
蓝色部分属于非受查异常：代码不会飘红，但是还是不能通过编译，必须用 throw 自己手动抛出异常。程序会自动停止并且告知用户。
还有特殊的自定义异常，即就是自己编写项目时，假如是用户登录的一个项目，在用户名称输入错误时，就应该停下来，告诉用户用户名输入错误，因为没有提供用户名称输入错误的异常，就可以重写编写一个类，并让其继承 Exception 类，代码如下：
public class Main{
public static void main(String[] args){
String username = "wpp";
try {
login(username);
} catch (UserNameException e) {
e.printStackTrace();
}
}
private static void login(String username) throws UserNameException {
if(!username.equals("wmf")){
throw new UserNameException("用户名输入错误！");
}
}
}
class UserNameException extends Exception{
public UserNameException(String message){
super(message);
}
}
1. try、catch、finally 捕获异常
public static void main(String[] args){
int[] arr = {1,2,3};
try{
System.out.println("before");
System.out.println(arr[100]);
System.out.println("after");
}catch (Exception ex){
ex.printStackTrace();
}
System.out.println("after and after");
}
- try代码块中放的是可能出现异常的代码
- catch代码块中放的时出现异常后的处理行为
- finally 代码块中的代码用于善后工作，会在最后执行。
- 一旦 try 中出现异常，那么try代码块中的程序就不会继续执行，而是交给 catch 中的代码执行。catch执行完会继续往下执行。
- finally 是在方法返回之前（try 或者 catch 中如果有return会在这个return 之前执行finally）。但如果 finally 中也存在 return 语句，那么就会执行 finally 中的return，从而不会执行 try 中原有的return。
2. throws
若是不想在本方法中 捕获处理该异常，则可以利用关键字，将异常抛出，在调用本方法的方法中捕获处理该异常。
3. throw 手动抛出非受查异常
public static int divide (int x, int y) throws ArithmeticException {
if (y == 0) {
throw new ArithmeticException("抛出除 0 异常");
}
return x / y;
}
public static void main(String[] args){
System.out.println(divide(2,0));
}
六. 用于包的关键字
package
import
- package ：用于将一部分代码包裹在一起，放在一个文件夹中。
- import ： Java中有写好的类，封装在指定的包中，在写代码有需要时可以利用import 将导入到写代码的类中直接调用
七. 其他修饰符关键字（5个）
native
strictfp
transient
volatile
assert
1. native
Java的跨平台使用，在一定程度上放弃了底层操作，因为不同的操作系统或者硬件的操作都是不同的。在Java来发一个软件时，控制不了底层，所以就需要与 C++ 联合开发。Java在调用其他接口的时候，可以用关键字 native 声明，意思是这个方法不是Java实现的。
Java是通过什么来调用外部代码的
JNI(Java Native Interface)这是一个本机编程的接口，它也是java jdk（开发工具包）的一部分，JNI可以支持java中使用其他语言，java要调用其他语言的接口，需要经过他处理。
2. strictfp
strictfp, 即 strict float point (精确浮点)。strictfp 关键字可应用于类、接口或方法。
如果想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp
- 使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。
- 当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。
3. transient
当串行化某个对象时，如果该对象的某个变量是transient，那么这个变量不会被串行化进去。也就是说，假设某个类的成员变量是transient，那么当通过
ObjectOutputStream把这个类的某个实例
保存到磁盘上时，实际上transient变量的值是不会保存的。因为当从磁盘中读出这个对象的时候，对象的该变量会没有被赋值。
4. volatile
用于多线程安全方面，
其他知识
扫一扫
6418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
