Java知识点

static关键字的作用：
static是静态的意思，可以修饰成员变量和成员方法。
static修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改。

public class User {   // 成员变量
   public static int onlineNumber= 161;
     private String name;
       private int age;
    }

成员变量可以分为2类
静态成员变量（有static修饰，属于类，内存中加载一次）: 常表示如在线人数信息、等需要被共享的信息，可以被共享访问。

public class User {
    // 静态成员变量
       public static String onlineNumber= 161;
       // 实例成员变量
         private String name;
            private int age;}

访问格式：
类名.静态成员变量。（推荐）
对象.静态成员变量。（不推荐）
对象.实例成员变量。
实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age、等属于每个对象的信息。
成员方法的分类：
静态成员方法（有static修饰，属于类），建议用类名访问，也可以用对象访问。
实例成员方法（无static修饰，属于对象），只能用对象触发访问。
表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。
工具类：
工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。
工具类的好处
一是调用方便，二是提高了代码复用（一次编写，处处可用）
为什么工具类中的方法不用实例方法做？
实例方法需要创建对象调用，此时用对象只是为了调用方法，这样只会浪费内存。
工具类的定义注意
建议将工具类的构造器进行私有，工具类无需创建对象。
里面都是静态方法，直接用类名访问即可。
static访问注意实现：
静态方法只能访问静态的成员，不可以直接访问实例成员。
实例方法可以访问静态的成员，也可以访问实例成员。
静态方法中是不可以出现this关键字的。
代码块概述
代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。
在Java类下，使用 { } 括起来的代码被称为代码块 。
代码块分为
静态代码块:
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

构造代码块（了解，用的少）：
格式：{}
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
使用场景：初始化实例资源。

静态代码块的作用是什么?
如果要在启动系统时对数据进行初始化。
建议使用静态代码块完成数据的初始化操作，代码优雅。
什么是设计模式（Design pattern）
开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
设计模式有20多种，对应20多种软件开发中会遇到的问题，学设计模式主要是学2点：
第一：这种模式用来解决什么问题。
第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。
单例模式
可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。
饿汉单例设计模式
在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。

/** a、定义一个单例类 */
public class SingleInstance {
   /** c.定义一个静态变量存储一个对象即可 :属于类，与类一起加载一次 */ 
    public static SingleInstance instance = new SingleInstance ();
   /** b.单例必须私有构造器*/  
     private SingleInstance (){       System.out.println("创建了一个对象");   }
     }

懒汉单例设计模式
在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。

设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。
提供一个返回单例对象的方法

/** 定义一个单例类 */class SingleInstance{
    /** 定义一个静态变量存储一个对象即可 :属于类，与类一起加载一次 */
   public static SingleInstance instance ;
    // null
       /** 单例必须私有构造器*/
          private SingleInstance(){}
              /** 必须提供一个方法返回一个单例对象  */
     public static SingleInstance getInstance(){       ...       
     return ...;  }
                  }

什么是继承、继承的好处
继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。
提高代码复用性，减少代码冗余，增强类的功能扩展性。
继承的格式
子类 extends父类
继承后子类的特点？
子类 继承父类，子类可以得到父类的属性和行为，子类可以使用。
Java中子类更强大。
需求：在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。
分析：
学生信息和行为（名称，年龄，所在班级，查看课表，填写听课反馈）
老师信息和行为（名称，年龄，部门名称，查看课表，发布问题）
定义角色类作为父类包含属性（名称，年龄），行为（查看课表）
定义子类：学生类包含属性（所在班级），行为（填写听课反馈）
定义子类：老师类包含属性（部门名称），行为（发布问题）

public class People {    
private String name;
   private int age;   
    /**     共同行为     */  
   public void queryCourse(){       System.out.println(name  + "，您可以开始查看您的课表信息了~~~");  
    }
       // getter + setter
       }
public class Student extends People{
    private String className;
        /**        独有行为    */
           public void writeInfo(){        System.out.println(getName() + "今天自己棒棒的，老师也是666~~~");    
           }  
            // getter + setter

}
public class Test {
    public static void main(String[] args) {
           Student s = new Student();
                 s.setName("翠花");  // 父类的
                 s.setAge(22); // 父类的       
                 s.setClassName("Java就业999期");// 子类的        
           System.out.println(s.getName());      System.out.println(s.getAge());       System.out.println(s.getClassName());       s.queryCourse(); // 父类的      
 s.writeInfo(); // 子类的   }
 }

继承的特点
子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
Java是单继承模式：一个类只能继承一个直接父类。
Java不支持多继承、但是支持多层继承。
Java中所有的类都是Object类的子类。
1、子类是否可以继承父类的构造器？
不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

2、子类是否可以继承父类的私有成员？
可以的，只是不能直接访问。
子类是否可以继承父类的静态成员？
有争议的知识点。
子类可以直接使用父类的静态成员（共享）
但个人认为：子类不能继承父类的静态成员。（共享并非继承）
Object特点：
Java中所有类，要么直接继承了Object , 要么默认继承了Object , 要么间接继承了Object, Object是祖宗类。
方法重写是什么样的？
子类写一个与父类申明一样的方法覆盖父类的方法。
方法重写建议加上哪个注解，有什么好处？
@Override注解可以校验重写是否正确，同时可读性好。
重写方法有哪些基本要求？
重写方法的名称和形参列表应该与被重写方法一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。
子类继承父类后构造器的特点：
子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。

为什么？
子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器的？
子类构造器的第一行语句默认都是：super()，不写也存在。
super调用父类有参数构造器的作用：
初始化继承自父类的数据。

如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢？
会报错。因为子类默认是调用父类无参构造器的。

如何解决？
子类构造器中可以通过书写 super(…)，手动调用父类的有参数构造器

public class Student {        
    private String schoolName;
      private String name;
   
    public Student(String name){
          this(name , “黑马培训中心”);	
    }	
     
    public Student(String name , String schoolName ){
          this.name = name;         this.schoolName = schoolName;
    }	
    }

this(…)和super(…)使用注意点：
子类通过 this (…）去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类构造器的。
注意：this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。
包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
导包
相同包下的类可以直接访问，不同包下的类必须导包,才可以使用！导包格式：import 包名.类名;
假如一个类中需要用到不同类，而这个两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问。
什么是权限修饰符？
权限修饰符：是用来控制一个成员能够被访问的范围的。
可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。
权限修饰符：有四种作用范围由小到大（private -> 缺省 -> protected - > public ）

final的作用
final 关键字是最终的意思，可以修饰（方法，变量，类）
修饰方法：表明该方法是最终方法，不能被重写。
修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。
修饰类：表明该类是最终类，不能被继承。
final修饰变量的注意
final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。
常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。
枚举的概述
枚举是Java中的一种特殊类型
枚举的作用：“是为了做信息的标志和信息的分类”。
定义枚举类的格式：
修饰符 enum 枚举名称{
第一行都是罗列枚举类实例的名称。
}

enum Season{  
 SPRING , SUMMER , AUTUMN , WINTER;
 }

枚举的特征：
枚举类都是继承了枚举类型：java.lang.Enum
枚举都是最终类，不可以被继承。
构造器都是私有的，枚举对外不能创建对象。
枚举类的第一行默认都是罗列枚举对象的名称的。
枚举类相当于是多例模式。

Compiled from "Season.java"
public final class Season extends java.lang.Enum<Season> {   public static final Season SPRING = new Season();    public static final Season SUMMER = new Season();    public static final Season AUTUMN = new Season();
public static final Season WINTER = new Season();    public static Season[] values();  
public static Season valueOf(java.lang.String);
}

案例说明：
现在开发的超级玛丽游戏需要接收用户输入的四个方向的信号（上下左右），以便控制玛丽移动的方向。

选择常量做信息标志和分类：
虽然可以实现可读性，但是入参值不受约束，代码相对不够严谨。

枚举做信息标志和分类：
代码可读性好，入参约束严谨，代码优雅，是最好的信息分类技术！建议使用!

1、抽象类的作用是什么样的？
可以被子类继承、充当模板的、同时也可以提高代码复用。
2、抽象方法是什么样的？
只有方法签名，没有方法体，使用了abstract修饰。
3、继承抽象类有哪些要注意？
一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法。
否则这个类也必须定义成抽象类。
不能用abstract修饰变量、代码块、构造器。
final和abstract是什么关系？
互斥关系
abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。
抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。
模板方法是给子类直接使用的，不是让子类重写的，
一旦子类重写了模板方法就失效了。
模板方法模式解决了什么问题？
极大的提高了代码的复用性
模板方法已经定义了通用结构，模板不能确定的定义成抽象方法。
使用者只需要关心自己需要实现的功能即可。
接口的定义与特点
接口的格式如下：
接口用关键字interface来定义
public interface 接口名 {
// 常量
// 抽象方法
}
JDK8之前接口中只能是抽象方法和常量，没有其他成分了。
接口不能实例化。
接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化。
接口的用法：
接口是用来被类实现（implements）的，实现接口的类称为实现类。实现类可以理解成所谓的子类。
修饰符 class 实现类 implements 接口1, 接口2, 接口3 , … {
}
实现的关键字：implements
从上面可以看出，接口可以被类单实现，也可以被类多实现。

接口实现的注意事项：
一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类。
JDK8开始后接口新增了那些方法?
默认方法：default修饰，实现类对象调用。
静态方法：static修饰，必须用当前接口名调用
私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用。
他们都会默认被public修饰。
接口的注意事项

1、接口不能创建对象
2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
什么是多态？
同类型的对象，执行同一个行为，会表现出不同的行为特征。
多态的常见形式
父类类型 对象名称 = new 子类构造器;
接口 对象名称 = new 实现类构造器;

多态中成员访问特点
方法调用：编译看左边，运行看右边。
变量调用：编译看左边，运行也看左边。（多态侧重行为多态）
多态的前提
有继承/实现关系；有父类引用指向子类对象；有方法重写。
多态下会产生的一个问题:
多态下不能使用子类的独有功能
自动类型转换（从子到父)：子类对象赋值给父类类型的变量指向。
强制类型转换吗（从父到子)
此时必须进行强制类型转换：子类 对象变量 = (子类)父类类型的变量
作用：可以解决多态下的劣势，可以实现调用子类独有的功能。
注意： 如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException
Animal t = new Tortoise();
Dog d = (Dog)t; // 出现异常 ClassCastException

Java建议强转转换前使用instanceof判断当前对象的真实类型，再进行强制转换
变量名 instanceof 真实类型
判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之。
内部类
内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。
public class People{
// 内部类
public class Heart{
…
}
}
内部类的使用场景、作用：

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
内部类通常可以方便访问外部类的成员，包括私有的成员。
内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。
内部类的分类
静态内部类[了解]
什么是静态内部类？
有static修饰，属于外部类本身。
它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。
public class Outer{
// 静态成员内部类
public static class Inner{
… }
}

静态内部类创建对象的格式：
格式：外部类名.内部类名 对象名 = new 外部类名.内部类构造器;
范例：Outer.Inner in = new Outer.Inner();
1、静态内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、静态内部类中是否可以直接访问外部类的实例成员？
不可以的，外部类的实例成员必须用外部类对象访问。
注意：在成员内部类中访问所在外部类对象 ，格式：外部类名.this

成员内部类（非静态内部类） [了解]
什么是成员内部类？
无static修饰，属于外部类的对象。
JDK16之前，成员内部类中不能定义静态成员，JDK 16开始也可以定义静态成员了。
public class Outer {
// 成员内部类
public class Inner {
}
}
成员内部类创建对象的格式：

外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();
范例：Outer.Inner in = new Outer().new Inner();
1、成员内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、成员内部类的实例方法中是否可以直接访问外部类的实例成员？
可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

局部内部类[了解]
局部内部类放在方法、代码块、构造器等执行体中。
匿名内部类（重点）
匿名内部类：
本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。
作用：方便创建子类对象，最终目的为了简化代码编写。
格式：
new 类|抽象类名|或者接口名() { 重写方法;};
Animal a = new Animal() { public void run() { }};
a. run();
特点总结：
匿名内部类是一个没有名字的内部类。
匿名内部类写出来就会产生一个匿名内部类的对象。
匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。