1、访问修饰符（public、private、protected）

访问修饰符：访问权限控制（以下权限范围由大到小，实心圆为常用关键字）

◉ public：公共的，整个工程都可以访问

◌ protected：受保护的（包级私有+子类），除了本包之外，继承该类的所有子类也可以访问

◌  默认的（无关键字）：包级私有，本类所在的包内所有的文件都可以访问

◉ private：私有的，本类内部才能访问

2、static修饰符

static关键字：类共享的

▶成员变量按有无static修饰，分为静态变量和实例变量。

有static修饰的成员变量叫做类变量 / 静态变量，属于类；

                        全体成员共享，往往用于公共静态常量的定义；

推荐使用  类名.静态变量名  来调用。

没有被static修饰的成员变量叫实例变量，属于对象。

在实例方法里不可以定义静态变量。

▶成员方法按有无static修饰，分为静态方法和实例方法。

有static修饰的成员方法叫做类方法 / 静态方法，属于类；

                        全体成员共享，往往用于工具方法不需要直接访问对象的定义；

推荐使用  类名.静态方法名()  来调用。

没有被static修饰的成员方法叫实例方法，属于对象。

静态方法不能直接访问成员变量和成员方法，需要用对象名来调用；

成员方法可以直接访问成员变量和类变量、类方法。

静态方法和实例方法

静态方法（Static Method）与静态成员变量一样，属于类本身。在类装载的时候被装载到内存（Memory），不自动进行销毁，会一直存在于内存中，直到JVM关闭。

非静态方法（Non-Static Method）又叫实例方法，属于实例对象。实例化后才会分配内存，必须通过类的实例来引用。不会常驻内存，当实例对象被JVM 回收之后，也跟着消失。

实例方法和静态方法的调用

1.如果不创建对象，那么通过类名称只能调用静态方法。
2.如果创建了对象，那么可以通过对象名调用实例方法。
3.通过对象名也可以调用静态方法，但是不推荐这么做。  

调用静态方法的格式：

方法名（参数值）;        //直接调用本类当中的静态方法
类名称.方法名（参数值）;    //调用另一个类中的静态方法

调用实例方法的格式： 

类名称 对象名 = new 类名称();    //首先创建对象
对象名.实例方法名(参数值);       //通过对象名调用实例方法

实例方法和静态方法的区别 

1. 调用方式不同：

实例方法 —— 对象名.方法名（同一个类中可以省略对象）

静态方法 —— 类名.方法名 （同一个类中可以省略类名）

2. 加载时期不同：

实例方法 —— 随着创建对象调用方法时加载

静态方法 —— 随着类的加载就会加载静态变量和静态方法

关于“无法从静态上下文中引用非静态” 的报错

静态方法可以在没有创建实例时使用，非静态的成员变量是一个对象属性，它只有在对象存在时引用。

案例：

class Test{ 
      public void t(){ 
             System.out.println("For test");
     ｝
 
      public static void main(String [] args){
              t();
      }
｝

因此 如果在对象未创建实例时，在静态方法中调用了非静态成员方法  就是非法的，所以编译器会在这种时候报错！！

修改1：让方法t()在实例中被调用（成员方法在调用时，要先new对象）

class Test{ 
      public void t(){ 
             System.out.println("For test");
     ｝
 
      public static void main(String [] args){
               Test test = new Test();
               test. t();
      }
｝

 修改2：将成员方法t()设为静态方法

class Test{ 
      public static void t(){ 
             System.out.println("For test");
     ｝
 
      public static void main(String [] args){
              t();
      }
｝

▶static{}：静态代码块

只在类第一次加载的时候，运行一次，之后不会再运行。

通常用于初始化静态变量，在静态方法中使用一些临时变量等。

如果有多个静态代码块，按顺序执行一次

静态代码块应该定义在静态变量后，否则不会访问静态变量 

// 单例模式：内存中只能有一个该类型的对象

---

this和super关键字

this 的作用：可以区别成员变量和局部变量

this 的本质：当前方法调用者的地址值

super：代表父类存储空间

一、Java当中this和super的区别：
1.属性的区别：
     （1）this访问本类中的属性，如果本类没有这个属性则访问父类中的属性。
     （2）super访问父类中的属性。 
2.方法的区别：
     （1）this访问本类中的方法，如果本类没有这个方法则访问父类中的方法。
     （2）super访问父类中的方法。 
3.构造的区别：
     （1）this调用本类构造，必须放在构造方法的首行。
     （2）super调用父类构造，必须放在子类构造方法首行。 
4.其他区别：
      this表示当前对象。super不能表示当前对象 
 
二、this. 属性和super.属性
     （1）this.属性：调用的当前对象的属性； 
     （2）super.属性：直接调用父类中的属性。 
 
三、this(参数)和super(参数)方法 
     （1）this(参数)：调用（转发）的是当前类中的构造器； 
     （2）super(参数)：用于确认要使用父类中的哪一个构造器。
 
四、注意点： 
     （1）在对拥有父类的子类进行初始化时，父类的构造方法也会执行，且优先于子类的构造函数执行；因为每一个子类的构造函数中的第一行都有一条默认的隐式语句super(); 
     （2）this() 和super()都只能写在构造函数的第一行； 
     （3）this() 和super() 不能存在于同一个构造函数中。
            1）this()和super()都必须写在构造函数的第一行；
            2）this()语句调用的是当前类的另一个构造函数而这个另一个构造函数中必然有一个父类的构造器，再使用super()又调用一次父类的构造器， 就相当于调用了两次父类的构造器，编译器不会通过； 
     （4）this和super不能用于static修饰的变量，方法，代码块；因为this和super都是指的是对象（实例）。

this.成员变量 代表本类对象，this()代表本对象的无参构造，this(...)代表本对象的有参构造

super.成员变量 代表父类对象，super()代表父类对象的无参构造，super(...)代表父类对象的有参构造

---

instanceof 关键字

instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。

它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

import java.util.ArrayList;
import java.util.Vector;
 
public class Main {
 
public static void main(String[] args) {
   Object testObject = new ArrayList();
      displayObjectClass(testObject);
   }
   public static void displayObjectClass(Object o) {
      if (o instanceof Vector)
      System.out.println("对象是 java.util.Vector 类的实例");
      else if (o instanceof ArrayList)
      System.out.println("对象是 java.util.ArrayList 类的实例");
      else
      System.out.println("对象是 " + o.getClass() + " 类的实例");
   }
}

 运行结果：

对象是 java.util.ArrayList 类的实例