匿名对象相关知识点：
匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
创建一个普通对象：引用类型变量可以反复使用
Person p = new Person();
P.eat();
创建一个匿名对象：没有引用变量，只能使一次
new Person(); 调用：new Person().eat();
int number=new Scanner( System.in).nextInt;
匿名对象的特点：
1、匿名方法可以直接使用，没有变量名。
例如：new Person().eat() //eat方法被一个没有名字的Person对象调用了。
2、匿名方法在没有指定其引用变量时，只能使用一次
例如：new Person().eat(); 创建一个匿名对象，调用eat方法
new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象
3、匿名方法可以作为方法接收的参数、方法返回值使用
参数传递
method(new Person());
public static void method(Person p){
p.eat();
}
方法返回值传递
Person p1=method();
p1.eat();
public static Person method( ){
Person p=new Person;
return p;
}
内部类的相关知识点：
什么是内部类：将类写在其他类的内部，可以写在其他类的成员位置和局部位置
注意事项：内部类编译好了也是以.class文件的形式存在的
分类：1、成员内部类 2、局部内部类
成员内部类：
注意事项：成员内部类也可以使用成员修饰符public、static。。。，也是个类，可以继承，可以实现接口
就近访问原则在内部类中同样适用哦~（下面代码省略测试类哦~）
public class Outer {//外部类
int i =1;
class Inner { //内部类
int i=2;
public void inner() {
int i=3;
System.out.println(i);//此处打印3（就近原则）
System.out.println(this.i); //此处打印2
System.out.println(Outer.this.i); //此处打印1
}
}
}
调用：1、内部类可以使用外部类的成员，包括私有属性（两个都是以同级的关系存在的）
2、外部类要使用内部类的成员，必须要先创建对象
- 定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
- 访问方式（重点）
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
对象.内部类方法（）；
- 成员内部类代码演示
class Body {//外部类，身体
private boolean life= true; //生命状态
public class Heart { //内部类，心脏
public void jump() {
System.out.println("心脏噗通噗通的跳")
System.out.println("生命状态" + life); //访问外部类成员变量
}
}
}
访问内部类：
public static void main(String[] args) {
//创建内部类对象
Body.Heart bh = new Body().new Heart();
//调用内部类中的方法
bh.jump();
局部内部类
就是把类写在方法里面
- 定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
- 访问方式（重点）
在外部类方法中，创建内部类对象，进行访问
- 代码演示
定义类
class Party {//外部类，聚会
public void puffBall(){// 吹气球方法
class Ball {// 内部类，气球
public void puff(){
System.out.println("气球膨胀了");
}
}
//创建内部类对象，调用puff方法
new Ball().puff();//这条代码等同于 Ball in=new Ball(); in.puff();
}
}
访问内部类
public static void main(String[] args) {
//创建外部类对象
Party p = new Party();
//调用外部类中的puffBall方法
p.puffBall();
}
内部类的实际使用——匿名内部类
作用：匿名内部类是创建某个类型子类对象的快捷方式（减少代码）
使用前提：继承或实现一个接口
定义匿名内部类有两个含义：1、临时定义某一个类型的子类。2、定义后即刻创建刚刚定义的这个子类的对象
格式：new 父类或接口(){//进行方法重写};
代码演示：
class XXX implements Smoking{ //实现类，实现接口 重写接口抽象方法，创建实现类对象
public void smoking(){
}
}
XXX x=new XXX();
x.smoking();
测试类
new Smoking(){
public void smoking(){
System.out.println("人在吸烟");
}
}.smoking();
两个代码是等价的，测试类中的代码如果没有“.smoking”代码将输出为空
使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
运用多态的方式，实现匿名内部类：
public static abstract Animal{
public abstract void eat();
public abstract void sleep();
}
测试类：
public class Test{
public static void main(String[] args) {
Animal a =new Animal(){//运用多态的方式，父类的引用指向子类的引用
public void eat(){
System.out.println("在吃饭");
}
public void sleep(){
System.out.println("在睡觉");
}
}；
a.eat();
a.sleep();
}
}
输出的结果为：在吃饭
在睡觉
访问修饰符相关知识点：
- 权限修饰符： public : 公共的 protected: 受保护的 默认 private : 私有的
public protected 默认的 private
在当前类中 Y Y Y Y
同一包中的其他类 Y Y Y
不同包中的子类 Y Y
不同包中的其他类 Y
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
- 要想仅能在本类中访问使用private修饰；
- 要想本包中的类都可以访问不加修饰符即可；
- 要想本包中的类与其他包中的子类可以访问使用protected修饰
- 受保护的权限，只能是子类的里面！！！调用父类的受保护成员
- 要想所有包中的所有类都可以访问使用public修饰。
- 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
代码块相关知识点：
分类：1、局部代码块 2、构造代码块（构造代码块、静态代码块）
局部代码块（限制生命周期或者是作用域）：局部代码块是定义在方法或语句中
特点：
- 以”{}”划定的代码区域，此时只需要关注作用域的不同即可
- 方法和类都是以代码块的方式划定边界的
class Demo{
public static void main(String[] args) {
{
int x = 1;
System.out.println("普通代码块" + x);
}
int x = 99;
System.out.println("代码块之外" + x);
}
}
结果：
普通代码块1
代码块之外99
构造代码块：构造代码块是定义在类中成员位置的代码块
特点：
- 优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
- 每创建一个对象均会执行一次构造代码块。
public class Person {
private String name;
private int age;
//构造代码块
{
System.out.println("构造代码块执行了");
}
Person(){
System.out.println("Person无参数的构造函数执行");
}
Person(int age){
this.age = age;
System.out.println("Person（age）参数的构造函数执行");
}
}
class PersonDemo{
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person(23);
}
构造代码块优先被执行
静态代码块： 静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
- 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
- 该类不管创建多少对象，静态代码块只执行一次。
- 可用于给静态变量赋值，用来给类进行初始化。
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println("静态代码块执行了");
}
}
静态代码块被优先执行
注意：（非常重要）（静态代码块>构造代码块>构造方法）
静态代码块，只执行一次
构造代码块，new一次，执行一次，优先于构造方法
构造方法，new一次，就执行一次