静态变量（类变量）
jdk8以前，他是存储在方法区的静态域的，jdk8以后，则是存储在堆中，加载类的时候生一个对应的class类对象，静态变量就在class类对象后面。
类变量是随着类的加载而创建，不需要创建对象实例也可以访问。
类变量使用注意事项和细节
1.什么时候需要用类变量当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量):比如: 定义学生类，统计所有学生共交多少钱。Student (name, staticfee)
2.类变量与实例变量 (普通属性) 区别类变量是该类的所有对象共享的，而实例变量是每个对象独享的
3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
4.类变量可以通过 类名.类变量名 或者 对象名.类变量名 来访问，但iava设计者推荐我们使用 类名.类变量名方式访问。[前提是 满足访问修饰符的访问权限和范围]
5.实例变量不能通过 类名.类变量名 方式访问
6.类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了就可以使用类变量了。
7.类变量的生命周期是随类的加载开始随着类消亡而销毁
类方法
加static的方法就是类方法，类方法可以访问静态属性。
开发自己的工具类时，可以将方法做成类方法，不需要实例化就可以调用。类方法使用注意事项和细节
1.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区
2.类方法中无this的参数普通方法中隐含着this的参数类方法可以通过类名调用，也可以通过对象名调用。
3.普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。
4.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以
5.类方法(静态方法)中 只能访问 静态变量 或静态方法
6.普通成员方法，既可以访问 非静态成员，也可以访问静态成员。
小结: 静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)
深入理解main方法
解释main方法的形式 : public static void main(String[] args)
1.main方法时虚拟机调用
2.java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
3.java虚拟机在执行main0方法时不必创建对象，所以该方法必须是static
4.该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
5.java 执行的程序 参数1 参数2 参数3[举例说明:]
public class Hello{
public static void main(String[] args){
for(int i=0;i<args.length;i++){
System.out.println("第"+i+1+"个参数="+args[i]);
}
}
}
C:\Users\BOCO\Documents\ysx>javac -encoding utf-8 Hello.java
C:\Users\BOCO\Documents\ysx>java Hello jl hi yi
第01个参数=jl
第11个参数=hi
第21个参数=yi
C:\Users\BOCO\Documents\ysx>
特别提示：
1.在main方法中，我们可以直接调用main方法所在类的静态属性
2.对于main方法所在类的非静态属性，必须创建该类的实例才能访问。
super
代码块
基本介绍
代码化块又称为初始化块,属于类中的成员[即 是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。
基本语法
[修饰符]{
代码
}
说明注意:
1)修饰符 可选，要写的话，也只能写 static
2)代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块
3)逻辑语句可以为任何逻辑语句输入、输出、方法调用、循环、判断等
4)；号可以写上，也可以省略
代码块的好处
1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
2)场景: 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性
代码块使用注意事项和细节
1)static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块， 每创建一个对象，就执行。
2)类什么时候被加载[重要!]
- 创建对象实例时(new)
2.创建子类对象实例，父类也会被加载
3.使用类的静态成员时(静态属性，静态方法)
案例演示:A类 extends B类 的静态块3)普通的代码块，在创建对象实例时，会被隐式的调用,3)被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行
4) 创建一个对象时，在一个类 调用顺序是:(重点，难点)
- 调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
- 调用普通代码块和普通属性的初始化(注意: 普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
- 调用构造方法。
5)构造 的最前面其实隐含了 super0和 调用普通代码块
静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的 CodeBlockDetailo3.java
public class CodeBlockDetailo3 {
public static void main(String[] args) {
new BBB();//(1)AAA的普通代码块(2)AAA()构造器被调用(3)BBB的普通代码块(4)BBB()构造器被调用
}
}
class AAA { //父类Object
{
System.out.println("AAA的普通代码块"):
}
public AAA(){
//(1)super()
//(2)调用本类的普通代码块
System.out.println("AAA() 构造器被调用。...");
}
}
class BBB extends AAA {
{
System.out.println("BBB的普通代码块...");
}
public BBB() {
//(1)super()
//(2)调用本类的普通代码块
System.out.println("BBB() 构透察被调用....");
}
}
6)我们看一下创建一个子类对象时(继承关系)，他们的静代码块静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下
1.父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
2.子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
3.父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
4.父类的构造方法
5.子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
6.子类的构造方法7)静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员。
单例模式
饿汉式
演示饿汉式和懒汉式单例模式的实现步骤如下:
1)构造器私有化 =》 防止直接 new
2)类的内部创建对象
3)向外暴露一个静态的公共方法。getinstance
package single;
public class SingleMorden{
public static void main(String[] args) {
// GirlFriend friend = new GirlFriend(); //无法创建
GirlFriend gf = GirlFriend.getInstance();
System.out.println(gf);
System.out.println(gf.toString());
GirlFriend gf2 = GirlFriend.getInstance();
System.out.println(gf2);
}
}
class GirlFriend{
private String name;
private static GirlFriend gf = new GirlFriend("yueer"); //这里static的使用是为了让下面getInstance方法调用
/*
* 如何保证只创建一个实例：
* 步骤：
* 1.构造器私有化
* 2.在类的内部直接创建
* 3.提供一个公共的static方法，返回实例
* */
private GirlFriend(String name){
this.name=name;
}
public static GirlFriend getInstance(){
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}
为什么称之为饿汉式？
因为这种实例一般都是重量级的，类加载的时候就已经创建好了这个实例，一直在等待被使用，你如果一直不调用它，是不是被冷落了？
懒汉式
懒汉式单例使用步骤：
* 1,构造器私有化
* 2，定义一个static属性私有对象
* 3，定义一个public静态方法，通过该方法生成实例
* 4，类对象只有在需要的时候调用getinstance方法创建一个对象，但是该方法存在线程安全问题，后面线程处完善
package single;
public class singleDemo01{
public static void main(String[] args) {
Cat c1 = Cat.getInstance();
System.out.println(c1);
Cat c2 = Cat.getInstance();
System.out.println(c2);
System.out.println(Cat.n);//这里调用类的属性，但却不对生成实例
}
}
class Cat{
private String name;
public static int n = 10;
private static Cat cat;
/*
* 懒汉式单例使用步骤：
* 1,构造器私有化
* 2，定义一个static属性私有对象
* 3，定义一个public静态方法，通过该方法生成实例
* 4，Cat对象只有在需要的时候调用getinstance方法创建一个对象，但是该方法存在线程安全问题，后面线程处完善
* */
private Cat(String name) {
System.out.println("构造器被调用");
this.name = name;
}
public static Cat getInstance(){
if(cat==null){
cat = new Cat("xiammi");
}
return cat;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
小结:
1.单例模式的两种实现方式
(1) 饿汉式
(2) 懒汉式
2.饿汉式的问题:在类加载时候就创建，可能存在资源浪费问题
3.懒汉式的问题: 线程安全问题，后面线程完善
在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式
final
final使用注意事项和细节
1)final修饰的属性又叫常量,一般 用 XX XX XX 来命名
2) final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一[选择一个位置赋初值即可]:1.定义时: 如public final double TAX RATE=0.08
2.定义好变量后在构造器中赋值
3.定义好变量后在代码块中赋值3)如果final修饰的属性是静态的，则初始化的位置只能是
1.定义时
2.在静态代码块,不能在构造器中赋值,因为静态变量在类加载时需要被赋值，而构造器在实例化对象时才会被调用。4)final类不能继承，但是可以实例化对象。
5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是类可以被继承。
6)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
7) final不能修饰构造方法(即构造器)
8)final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。
执行结果
9)包装类(Integer,Double,Float，Boolean等都是final),String也是final类
abstract
抽象类：
当我们有一些方法不好实现时，用abstract修饰该方法，让其子类去实现。抽象类使用的注意事项和细节
1)抽象类不能被实例化
2)抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
3)一旦类包含了abstract方法,则这个类必须声明为abstract
4)abstract 只能修饰类和方法，不能修饰属性和其它的。
5)抽象类可以有任意成员[抽象类还是类]，比如: 非抽象方法、构造器、静态属性等等
6)抽象方法不能有主体，即不能实现.
7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
8)抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
private修饰属性是类私有的，不能继承
final修饰的方法不能被继承
static和继承毫无关系，abstract方法无方法体，如果用static修饰该方法是可以直接通过类调用，调用一个没有方法体的方法没有任何意义。
interface
基本介绍
接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。
语法:
interface 接口名{
//属性
//方法
}
class 类名 implements 接口{
自己属性;
自己方法;
必须实现的接口的抽象方法
}
小结:
1.在Jdk7.0前接口里的所有方法都没有方法体，即默认都是抽象方法
2.Jdk8.0后接口可以有静态方法（static），默认方法（default），也就是说接口中可以有方法的具体实现
接口注意细节
//1.接口不能被实例化
//2.接口中所有的方法是 public方法， 接口中抽象方法，public，abstract 可以省略
//3一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
5、一个类同时可以实现多个接口
6、 接口中的属性,只能是final的，而且是 public static final 修饰符。
比如:
int a=1;
实际上是 public static final int a=1;(必须初始化)
7、接口中属性的访问形式: 接口名.属性名（默认public static final）
8、 接口不能继承其它的类,但是可以继承多个别的接口
interface A extends B,C{}
9、接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
注：类实现接口，类实例可以直接访问接口的属性，类也可以直接访问接口属性，接口可直接访问接口属性
interface A{
fint a=23;
}
class B implements A{
}
main函数中:
B b=new B();
System.out.println(b.a); //32
System.out.println(A.a);//32
System.out.println(B.a);//32
实现接口 vs 继承类
接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性设计，设计好各种规范(方法)，让其它类去实现这些方法。即接口的价值主要在于:更加的灵活…
接口比继承更加灵活 接口比继承更加灵活，继承是满足 is - a的关系，而接口只需满足 like - a的关系
接口在一定程度上实现代码解耦[即: 接口规范性+动态绑定]
四种内部类
局部内部类
说明:局部内部类是定义在外部类的局部位置，比如方法中，并且有类名
1.可以直接访问外部类的所有成员，包含私有的
2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final 修饰，因为局部变量也可以使用final
3.作用域: 仅仅在定义它的方法或代码块中。
4.局部内部类—访问]---->外部类的成员 [访问方式:直接访问]
5.外部类—访问---->局部内部类的成员访问方式:创建对象，再访问(注意: 必须在作用域内)
6.外部其他类—不能访问----->局部内部类(因为 局部内部类地位是一个局部变量)
7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用 (外部类名.this.成员)去访问。外部类名.this实质上指的就是外部类当前创建的对象。
匿名内部类
(1) 本质是类(2) 内部类(3)该类没有名字(4)同时还是一个对象说明:匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
1.匿名内部类的基本语法
new 类或接口(参数列表)类体注：匿名内部类只能用一次，但是他生成的对象可以多次调用
A a = new B{类体}
a的编译类型是A，运行类型是匿名内部类，匿名内部类jvm会为他分配一个类名，可以通过a.getClass来获得。2.匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义
同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征
3.可以直接访问外部类的所有成员，包含私有的
4.不能添加访问修饰符,因为它的地位就是一个局部变量。
5.作用域 : 仅仅在定义它的方法或代码块中。
6.匿名内部类—访问---->外部类成员[访问方式:直接访问]
7.外部其他类—不能访问------>匿名内部类(因为 匿名内部类地位是一个局部变量)
8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则如果想访问外部类的成员，则可以使用 (外部类名.this.成员》去访问
成员内部类
说明：成员内部类是定义在外部类的成员位置，并且没有static修饰
1.可以直接访问外部类的所有成员，包含私有的
class Outer01{
//外部类
private int n1 = 10:
public String name = "张三"
class Innter01{
public void say(){
System.out.println("Outer01 的n1 = " + 1 + " outer01 的 name = " + name )
}}}
2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
3.作用域
和外部类的其他成员一样，为整个类体
4.成员内部类—访问---->外部类成员(比如属性)访问方式: 直接访问
5.外部类—访问------>成员内部类(说明)访问方式: 创建对象，再访问
6.外部其他类—访问---->成员内部类
有以下三种方式：
public class Testlnner3{
public static void main(Stringl args){
//其它外部类访问内部类的三种方式，
//方式1
Outer01 outer01 = new Outer01();
Innter01 innter01 = outer01.new Innter01();
//方式2:和1差不多一样
Innter01 innter012 = new Outer01().new Innter01():
//方式3: 使用一个方法来获取，更加简洁
Innter01 innter01lnstance = new Outer01().getlnnter01nstance();
}}
class Outer01{
private int n1 = 10;
public String name = "张三";
class Innter01{
public void say(){
System.out.println("Outer01 的 n1 ="+ n1 + "outer01 的 name = " + name );
}
}
public Innter01 getlnnter01lnstance(){
return new Innter01();
}
private void show() {
Innter01 innter01 = new Innter01(0);
innter01.say():
}
}
7.如果外部类和内部类的成员重名时,内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问
静态内部类
说明:静态内部类是定义在外部类的成员位置，并且有static修饰
1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是个成员。
3. 作用域 : 同其他的成员，为整个类体
4.静态内部类—访问---->外部类成员(比如属性)访问方式: 直接访问
5.外部类—访问------>静态内部类(说明)访问方式: 创建对象，再访问
6.外部其他类—访问---->静态内部类(和内部类类似)
第一种：通过一个方法返回实例对象
第二种：通过***外部类.内部类()***新建一个对象
7.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问处部类的成员，则可以使用 (外部类名.成员)去访问
扫一扫
1164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
