匿名对象：没有名字的对象
//普通对象调用方法
Student s=new Student();
method(s);
//匿名对象调用方法
//只调用一次
method(new Student());
//定义方法
public void method(Student s){
}普通对象和匿名对象的区别
1》普通对象的创建：Student s=new Student();在堆中创建
普通对象的销毁：s在main方法中声明，等main方法出栈后，对象的引用s在栈内存中
消失。此时堆内存的地址值就和main方法没有关系，jvm将其标记为垃圾数据。
2》匿名对象的创建：method(new Student());将对象的地址值和方法method的形参s关联。
method方法出栈后，匿名对象就会被标记为垃圾数据。这样更早的会被垃圾扫描器清除，提高内存的使用率
弊端：只能使用唯一的一次
类中的私有方法（private修饰的方法）
私有方法特点：只能在本类中进行访问。
应用场景：类中多个方法存在共性内容时，可以将多个方法的共性内容抽取为私有化方法（不对外界提供）
构造器代码块：【类中方法外】
当类中所有构造器存在相同代码时，可以将这些相同代码提取到构造器代码块.
注意：构造器代码块是由构造器中的第二部分隐式代码隐式调用。
1.构造器代码块不是优先于构造器调用，但可以说优先于构造器中显示代码调用。
部分构造器有相同的代码：
this关键字第二种用法，在(子)类中构造器：
this（实参）： 调用类中其他构造器完成初始化工作。
有了this（），构造器就只执行一次
public class Teacher {
private String name;
private int age;
public Teacher() {
this(1);
System.out.println("无参构造器");
}
public Teacher(int i) {
this(1,2);
System.out.println("1个参数构造器");
}
public Teacher(int i,int j) {
//控制台打印的唯一一个构造器代码块是这里的隐式代码
System.out.println("2个参数构造器");
}
{
System.out.println("构造器代码块");
}
}
测试类调用：
public static void main(String[] args) {
new Teacher();
}
结果：
1
static ：静态的、共享的。
1.被static修饰的内容不再属于对象，归属于类。会被这个类所创建的对象共享
2.被static修饰的内容随着类的加载而加载。主要指类文件（字节码对象）的加载而加载
而且字节码只加载一次，static修饰的内容也只加载一次.
调用：类名.静态变量名（推荐）;也可以对象名.静态变量名(不推荐)
在方法区中有：
字节码文件区：用来存储字节码文件对象。
静态区：有默认值（因为方法区归属于堆）
静态区里有jvm监视器，用来检测main方法有没有进入静态区。监视器通过jvm调用
main方法，main方法进栈。
学生学号id自增的功能
public class Student {
//学生学号id自增的功能
static int num=220411001;
//构造器代码块
{
this.id=num++;
}
private int id;
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void study() {
System.out.println(id+" :学生-"+name+":"+age+"岁");
}
}
测试类：
public class Demo {
public static void main(String[] args) {
Student s1 = new Student("乱古大帝",13);
Student s2 = new Student("无终大帝",15);
Student s3 = new Student("弃天大帝",17);
s1.study();
s2.study();
s3.study();
Student s4 = new Student();
s4.setName("荒天帝");
s4.setAge(9);
s4.study();
}
}结果：
1
静态方法
1.被static修饰的方法不再属于对象，而是归属于类。会被这个类创建的所有对象所共享
工具类里的方法习惯声明为静态方法。静态区不管用不用都已经创建好了，而new对象需要
开辟堆内存空间。为了防止对象强制创建，需要对构造器私有化。
比如api的类MATH，Arrays 构造器私有化，里面方法全部都是static方法
2.静态方法随着类的加载而加载。这里加载指静态方法进入静态区且只加载唯一的一次。
而静态方法的调用则进入栈内存，方法不调用不执行。
3.静态方法中不可以使用this关键字。
4.静态方法中调用成员关系：
实例方法中调用非静态成员：成立
实例方法中调用静态成员：成立
静态方法中调用静态成员：成立
静态方法中调用非静态成员：不成立
面试题为什么：静态方法中调用非静态成员不成立
静态代码块
static{
System.out.println("静态代码块");//静态代码块只加载一次
}
位置：类中方法外
作用：1.用来提高对象的加载时机，封装高级工具类。（jdbc封装工具类）
2.在类的初始化过程面试题中会出现
3.给静态常量进行初始化赋值
1.静态代码块随着类的加载而加载，且只加载唯一的一次。
2.静态代码块中无法使用非静态成员。
3.静态代码块中无法使用this关键字。
static综合运用单例设计模
单例设计模式：
解决只创建唯一对象的固定解决方案。
立即加载模式（饿汉式）：
1、私有化构造器。
2. 在模块类中定义并创建唯一的对象
3. 为了外界方便访问，将唯一的对象变量修饰为static
4. 为了安全，将唯一的对象变量修饰为private
Ceo c1=CEO.ceo;
CEO.ceo=null;//安全起见，故需要对其私有化
Ceo c2=CEO.ceo;
Ceo c3=CEO.ceo;5,私有化后需要对外提供公共的get获取方式。
public class Teacher {
private static Teacher teacher=new Teacher();
private Teacher() {
}
public static Teacher getTeacher() {
return teacher;
}
}测试类：
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
Teacher t3 = Teacher.getTeacher();
System.out.println(t1);
System.out.println(t2);
System.out.println(t3);
}
延迟加载模式（懒汉式）
立即加载模式的弊端：
当加载唯一对象对应得类时，我们不会马上使用这个唯一得对象，就会造成内存资源得浪费。
1、私有化构造器。
2. 定义唯一的对象变量，不进行初始化。
3. 为了外界方便访问，将唯一的对象变量修饰为static
4. 为了安全，将唯一的对象变量修饰为private
private static CEO.ceo;
5,在第一次访问的时候 (判断条件ceo=null)
public static CEO getCEO(){
if(ceo=null){
ceo=new CEO();
return ceo;
}else{
return ceo;
}
}
