类变量和类方法：
类变量（静态变量）：
1.无论static变量存储在哪里共识是：static属性是本类所有对象共享的
2.static变量是在类加载的时候就生成了
3.任何一个该类的对象去访问他时，取到的都是相同的值，同样的任何一个该类的对象去修改它时，修改的也是同一个变量
定义语法：
访问修饰符 static 数据类型 变量命; （推荐）
static 访问修饰符 数据类型 变量名 ;
如何访问类变量：
类名.类变量名 或 对像名.类变量名【静态变量的访问修饰符权限和范围 和 普通属性是一样的】
细节：
何时使用类变量？
答：当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）：eg：定义学生类统计所有学生要交多少钱
2.类变量与普通属性的区别
类变量是所有对象共享的，而实例变量是每个对象独享的
3.加上static称之为类变量
4.实例变量不能通过类名.变量名的方式访问
5.类变量在加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了
6.生命周期随类的加载开始，随类的销毁而销毁
使用方式： 类名.变量名
类方法（静态方法）：
命名形式：访问修饰符 static 数据返回类型 方法名（）{ }（推荐方法） 或 static 访问修饰符 数据返回类型 方法名（）{ }
类方法的调用： 类名.方法名 或者 对像名.类名【记得要符合访问修饰符规则哦】
成员方法与类static方法相互调用规则：
- 静态方法内部只能够调用调用静态方法或者是静态变量，不能够调用成员方法和成员变量；
- 非静态方法内部能够调用成员方法和成员变量，也可以调用静态方法和静态变量；
类方法经典使用场景：
当我们在开发时 当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率。
eg：工具类中的方法 utils
类方法使用细节：
1）类方法和普通方法都是随着类的加载而加载，将结构信息储存在方法区； 类方法中无 this 参数；普通方法中隐含着this参数
2）类方法可以通过类名调用，也可以通过对像名调用
3）普通方法和对象有关，需要通过对象名调用 ，eg：对像名.方法名（参数）， 不能通过类名调用
4）类方法中不允许使用和对象有关的关键字，比如 this和super 普通方法（成员方法可以）
5） 类方法（静态方法）中 只能访问 静态变量 静态方法
使用方式： 类名.方法名
main方法：
1.main方法在执行时由java虚拟机调用
2.java虚拟机需要调用类的main（）方法（调用时根本不在同一个类，所以是public），所以访问权限必须时public
3.java虚拟机在执行main（）方法时不用创建对象·，所以为static
4.该方法接收String类型的数组参数，该数组保存执行java命令时传递给所运行类的参数
5.Java程序执行
细节：
1）在main中，我们可以直接调用main方法所在的类的静态方法或静态属性
2）不能直接访问本类的静态成员，必须创建一个实例对象后才能访问
idea main 参数传递
代码块：（相当于对构造器的补充机制）
基本介绍：代码块又称为初始化块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中通过{}包围起来。
与方法的差别在于，没有方法名，没有返回，没有参数，只有方法体，而且不通过对象或类显式调用，而是加载类或创建对象时隐式调用。
基本语法
[修饰符]{
代码
}；
注意：
1） 修饰符 可选，要写的话也只能写成static
2）代码块分为两类：普通代码块（无static修饰）静态代码块（有stati修饰）
3）逻辑语句可以为任何逻辑语句（输入 输出 方法调用 循环 判断等）
4）; 可以省略 也可以写上
使用细节：
1）static 代码块 作用是对类进行初始化，伴随着类的加载而执行， 并且只会执行一次，如果是普通代码块，每创建一个对象就执行
2）类什么时候被加载：
创建对象实例的时候（new）
创建子类对象实例的时候，父类也会被加载（父类先被加载，子类后被加载）
使用类的静态成员时（静态属性，静态方法）
3）普通代码块，在创建对象实例时，会被隐式调用。
被创建一次，就会调用一次·
如果只是使用类的静态成员时，普通代码块并不会被执行
4）创建一个对象时，在一个类 调用的顺序是：（重难点）
（最先执行）调用静态代码块和静态属性初始化（注意：静态代码块和静态初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按照他们的定义顺序调用）
（其次执行）调用普通代码块和普通属性初始化（注意：普通代码块和普通属性初始化的调用优先级一样 如果有多个普通代码块和多个普通变量初始化，则按照他们的定义顺序调用）
（最后执行）调用构造方法
5）构造器 的最前面其实是隐含了 super（）和 调用普通代码块
静态代码快只能调用静态成员 普通代码块可以调用任意成员
单例设计模式：
什么是设计模式
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。
单例模式 ：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（1）饿汉式 2）懒汉式）
饿汉式和懒汉式单例模式的实现
1）构造器私有化（防止直接去new）
2）类的内部创建对象
3）向外暴露一个静态的公共方法
懒汉模式：
public class SingletonIdler {
public static void main(String[] args) {
System.out.println(Cat.getCat());//小李的可爱猫猫来啦!!!!!
}
}
//猫类
class Cat {
//将属性私有化
private String name;
//将构造器私有化 使得main方法中不能创建新的对象;
private Cat(String name) {
this.name = name;
}
//创建一个静态属性
// 该静态属性 是为了 接收 新建的对像的 值
private static Cat cat = null;
//给一个getCat方法使得main方法中可以调用
public static Cat getCat() {
if (cat == null) {
//此处的cat为静态的 已经创建了 如果使用
// Cat cat = nwe Cat();那么此处的cat
// 就是一个新的属性
cat = new Cat("小李的可爱猫猫");
}
//此处就返回了 cat 值
return cat;
}
//还有一件事,因为返回的是对象哦~~~~~~记得重写toString方法
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
//开始 run 一下吧
}
final关键字：
final 可以用来修饰 类 属性 方法 和 局部变量
final的使用需求：
1）当不希望类被继承时 可以用final修饰
2）当不希望父类的某个方法 被子类覆盖 重写时
3）当不希望类的某个属性值被修改（比如说收税的税率）
4）当不希望某个局部变量被修改
final 使用细节：
1）final修饰的属性又叫常量 一般用XXX_或XXX_XXX来命名
2）final 修饰的属性在定义后必须赋初值 并且以后不能再修改
可以在以下位置赋初值 定义时：public final double TAX_RATE= 0.08；
在构造器中 ：
直接赋值·
在代码块中：
直接赋值
3）如果 final 修饰的属性是静态的 则初始化的位置只能是
（1）定义时（2）静态代码块 不能在构造器赋初值（注解：静态常量会进行类加载在类加载时必须有之值 但是 构造器中的赋值是创建一个对象的所以不能使用构造器给 final修饰的静态属性赋值）
4）final类不能被继承 但是可以实例化对象
5）如果不是final类但是 含有final方法 则该方法不能被重写
可以被继承
6）一般来说 一个类已经是final类了就没必要在将方法修饰成final方法了
7）final 不能修饰构造方法（即构造器）
8）final 和static 一般搭配使用，不会导致类的加载 效率更高 ，底层编译器做了优化处理（注释：在main方法里调用该静态属性 用final修饰不会导致类的加载 静态代码块就不会被执行）
9）包装类（Integer ，Double ， Float ，Boolean等都是final类），String也是final类
10）方法里的形参支持加上final修饰
抽象类：
当父类的某些方法，需要声明，但是又不确定如何是现时，可以将其声明为抽像方法，那么这个类就是抽象类
抽象类基本介绍：
1）用abstract 关键字来修饰一个类时，这个类就叫做抽象类
访问修饰符 abstract 类名{
}
2）用abstract 关键字来修饰一个方法时，这个方法就是抽象方法（抽象方法没有方法体 一个类中如果有抽象方法，那么这个类必须是抽象类）
访问修饰符 abstract 返回类型 方法名（参数列表）；
3）抽象类的价值更多作用在设计，是设计者设计好后，让子类继承并实现抽象类（）
4）抽象类在框架和设计模式使用较多
使用细节：
1）抽象类不能被实例化
2）抽象类不一定要包含abstract 方法。也就是说，抽象类可以没有abstract 方法，还可以有实现的方法
3）一旦包含了 abstract 方法 ，则这个类必须声明成abstract类
4）abstract 只能修饰类和方法，不能修饰属性和其他
5）抽象类可以拥有任意成员 【抽象类还是类】 ，比如：非抽像方法 构造器 静态属性等
6）抽象方法不能有主体
7）如果一个类继承了抽象类 ，则它必须实现抽象类的所有抽象方法，除非他自己也声明为抽象类（所谓实现就是要有方法体）
8）抽象方法不能使用private final static来修饰，因为这些关键字都是和重写相违背的
接口：（对单继承机制的一种补充）
基本介绍：接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候 再根据具体情况把这些方法写出来
interface 接口名{
//属性
//方法
}
class 类名 implements 接口{
自己属性；
自己方法；
必须实现的接口的抽象方法
}
小结：1.在jdk7.0前 接口里的所有方法都没有方法体（都是抽象方法）
2.jdk8.0后 接口类里可以有静态方法，默认方法
也就是说 接口 中可以有方法的具体实现（条件需要有default关键字修饰）
注意事项和使用细节 ：
1）接口不能被实例化
2）接口中所有的方法是public方法, 接口中抽象方法 ，可以不用abstract修饰
3）一个普通类实现接口，就必须将该接口的所有方法都实现
4）抽象类实现接口，可以不用实现接口的方法
5）一个类可以实现多个接口
6）接口中的属性只能是final的，而且是 public static final 修饰符 成员方法默认修饰符为： public abstract
（属性必须初始化）
7）接口中属性的访问形式：接口名.属性名
8）一个接口不能继承其他的类，但是可以继承多个接口
interface A extends B，C { }
9）接口的修饰符 只能是 public（单独文件名和接口名一样） 和默认 ，这点和类的修饰符是一样的
接口的多态性：
多态参数：
在该案例里 实现了接口的类能作为实参传递进去调用
实现了接口的多态 提高了代码的复用性
类似于 多态里面的向下转型 使得父类可以调用子类的 特有方法 （注意动态类型绑定）
如果存在两个接口 一个类 这两个接口为AA BB BB继承了AA
此时就算该类实例了 接口的传递现象 存在AA BB 两个接口 CC 实现BB接口 此时可以用BB 创建变量指向 CC 如果想让AA也指向CC 就让BB 继承AA
这就是接口的多态传递现象
内部类：
基本介绍 一个类的内部又完整嵌套了另一个结构。 被嵌套的结构称为内部类 ，而嵌套其他类的类称之为外部类
内部类最大的特点是可以直接访问私有属性，并且可以体现类与类之间的包含关系
基本语法：
class Outer{//外部类
class Inner {//内部类
}
}
class Other {//其他外部类
}
内部类的分类
定义在外部类局部位置上（方法内）
1）局部内部类
2）匿名内部类
定义在外部类的成员位置上
1）成员内部类（没有用static修饰）
2）静态内部类（用static修饰）
局部内部类的使用：
说明 局部内部类是定义在外部类的局部位置 ，比如方法中 并且有类名
1.可以直接访问外部类的所有成员 包含私有的
2.不能添加访问修饰符 因为它的地位就是一个局部变量。局部变量是不能使用访问修饰符的。但是可以用final修饰，因为局部变量也可以用final
3.作用域 仅仅在定义它的方法或代码块中。
4.局部内部类 访问 外部类成员（访问方式 直接访问）
5. 外部类访问 局部内部类 成员 （访问方式：创建对象，在访问 ps：必须在作用域内）
记住:(1)局部内部类定义在方法中/代码块
(2)作用域在方法体或者代码块中
(3)本质仍然是一个类
6）外部其他类 --------不能访问局部内部类（因为局部内部类的地位是一个局部变量）
7）如果外部类和局部内部类的成员重名时，默认遵从就近原则如果想访问外部类的成员则可以使用（外部类名 .this.成员）
/**
* 演示局部内部类的使用
*/
public class InnerClass {
public static void main(String[] args) {
//演示一遍
Outer02 outer02 = new Outer02();
outer02.m1();
System.out.println("outer02 的 hashcode=" + outer02);
}
}
class Outer02 {//外部类
private int n1 = 100;
private void m2() {
System.out.println("Outer02 m2()");
}//私有方法
public void m1() {//方法
//1.局部内部类是定义在外部类的局部位置,通常在方法
//3.不能添加访问修饰符,但是可以使用 final 修饰
//4.作用域 : 仅仅在定义它的方法或代码块中
final class Inner02 {//局部内部类(本质仍然是一个类)
//2.可以直接访问外部类的所有成员，包含私有的
private int n1 = 800;
public void f1() {
//5. 局部内部类可以直接访问外部类的成员，比如下面 外部类 n1 和 m2()
//7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
// 使用 外部类名.this.成员）去访问
// 老韩解读 Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象
System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
System.out.println("Outer02.this hashcode=" + Outer02.this);
m2();
}
}
//6. 外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}
匿名内部类：（重要!!!!!!!!!!!!）
说明：匿名内部类是 定义在外部类的局部位置 ，比如方法中，并且没有类名（类名由系统分配了）
匿名内部类使用场景 在开发时 该类只是使用一次后面就不再使用
（1）本质是类 （2）内部类 （3）该类没有名字（类名由系统分配了）（4）同时还是一个对象
1）匿名内部类的基本语法
new 类或接口 （参数列表）{
类体
}
//如下代码解释基于接口的匿名内部类
package incnerclass;
//基于接口的匿名内部类
//1.需求： 想使用 IA 接口,并创建对象
//2.传统方式，是写一个类，实现该接口，并创建对象
//3.需求是 Tiger/Dog 类只是使用一次，后面再不使用
//4. 可以使用匿名内部类来简化开发
//5. tiger 的编译类型 ? IA
//6. tiger 的运行类型 ? 就是匿名内部类 Outer$1
public class AnonymousInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.m3();
}
}
class Outer {//外部类
//方法
public void m3() {/*
匿名内部类在jdk底层是
class Outer$1 implements IA(){
@Override
public void cry() {
System.out.println("老虎喵喵叫~~~~~~");
}并不是没有名字 而是系统自动分配 在底层 只会 使用一次
*/
//匿名内部类
IA tiger = new IA() {
@Override
public void cry() {
System.out.println("老虎喵喵叫~~~~~~");
}
};
tiger.cry();//只使用一次的意思是该类只使用一次 此处已将值赋值给了tiger
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
tiger.cry();
}
}
interface IA {
public void cry();
}
基于类的匿名内部类：
基于类的匿名内部类相当于继承了该类
如果类的构造器含有参数列表 那么 匿名内部类里给的参数会直接传入类的构造器
匿名内部类使用细节
1.匿名内部类的语法比较奇特，请大家注意，因为匿名内部类即是一个类的定义 同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此 可以调用匿名内部类的方法
将此 匿名内部类直接当作对象 调用方法（注意:动态绑定吼）
2.可以直接访问外部类的所有成员 包含私有的
3.不能添加访问修饰符 因为它的地位就是一个局部变量
4.作用域 ：仅仅在定义它的方法或代码块中（因为匿名内部类地位仅仅是一个局部变量）
5.匿名内部类 访问 外部类成员[访问方式 ：直接访问]
7.外部其他类 不能访问匿名内部类 （因为匿名内部类的地位是一个局部变量）
8.如果外部其他类 和 内部类的成员重名时，内部类访问的话，默认遵循 就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
应用场景一：
package incnerclass;
public class AnonymousInnerClass01 {
public static void main(String[] args) {
//有两种方法
//法一 通过调用f1 把匿名内部类当作f1的实参
//此处的原理是将 匿名内部类当作一个对象直接传递给f1
//优点 随改随用 不会影响其他
f1(new IM() {
@Override
public void sou() {
System.out.println("我不想上早读~~~~~");
}
});
//创建该类的实例化对象 调用重写的方法
Temp temp = new Temp();
temp.sou();
}
//static实现在main()里不创建对象就能调用
//形参是接口类型的 可以直接调用接口里面的方法
public static void f1(IM im) {
im.sou();
}
}
interface IM {
void sou();
}
//法二
//用一个类去实现该接口 然后在调用该类
class Temp implements IM {
@Override
public void sou() {
System.out.println("可是不上早读真的很爽欸!!!!!");
}
}
二者对比 将匿名内部类当作实参传递的方法更为灵活 如果想要修改 就直接 在匿名内部类重写的方法中修改 不会影响其它
但是新建一个类去实现接口的方法 如果进行修改的话 该类的所有实例化对象都会受到影响
成员内部类：
说明：成员内部类 是定义在外部类的成员位置 ，并且没有static修饰。
1.成员内部类 可以直接访问外部类的所有成员 ，包含私有的
2.可以添加任意的访问修饰符 因为它的地位就是一个成员
package incnerclass;
public class MemberClassInner {
public static void main(String[] args) {
Niu niu = new Niu();
//不能通过该外部类的对象 调用 成员内部类的方法
niu.prin();
}
}
class Niu {
private int age = 23;
public String name = "李四";
class Sout_ {//成员内部类
public void Infr() {
System.out.println("name : " + name + " age :" + age);
}
}
public void prin() {
Sout_ sout_ = new Sout_();
sout_.Infr();
}
}
3.作用域 和外部类的其他成员一样，为整个类体 调用时 需要在外部类中创建对象 然后再调用
4.成员 内部类 访问 外部类的成员 访问方式 直接访问
5. 外部类 访问 成员内部类的属性 和方法（先创建 对象 然后 通过 对象 访问）
6.外部 其他类 访问成员内部类
两种方式
（1）Niu niu = new Niu();
Niu.Sout_ sout_ = niu.new Sout_();（原理 因为成员内部类 相当于 外部类的 一个 成员 所以 在创建 成员 内部类的对象时 语法就变成了 外部类名.内部类名 对像名 = 外部类对像名.new 内部类名（）；）
（2） 在外部类中 编写一个方法 ，可以返回 成员内部类的对象
在其他外部类中用 外部类名.内部类名 对像名 = 外部类对像名.该方法名（）； 来接收 之后通过 该对像名来调用成员内部类的方法和属性
7.如果外部其他类 和 成员内部类的成员重名时，内部类访问的话，默认遵循 就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
静态内部类：
说明：静态内部类是定义在外部类的成员 位置 并且有 static修饰
1.可以直接访问 外部类的 所有静态成员，包含私有的 但是不能直接访问非静态成员
2.可以添加任意的访问修饰符 因为地位就是一个成员
3.作用域 ：同其他成员一样 为整个类体
4. 静态内部类 访问 外部类（比如 静态属性）访问方式 直接访问静态内部类的所有成员
5. 外部类 访问 静态内部类 创建对象 再访问（注意：类是静态的 但是里面的 属性和方法不一定是静态的 如果 该类的成员或方法不是 静态的 就不能通过 类名.方法/属性名 来调用）
6.外部 其他类 访问静态内部类
方法一：（前提是符合修饰符的访问规则）
（1）外部类名.内部类名 对像名 = new 外部类名.静态内部类名（）;（原因 静态内部类 相当于静态的属性 可以类名.属性名直接 调用 不用再创建对象）
7.如果外部其他类 和 成员内部类的成员重名时，内部类访问的话，默认遵循 就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问（注意此处的访问没有this!!!!!!!）
面向对象完结撒花！！！！！！！！！！！！！！！！！！！！
扫一扫
2380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
