1、匿名对象
（1）概述：匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
例如：
public class Person{ public void eat(){ System.out.println(); } }
创建一个普通对象
Person p = new Person();
创建一个匿名对象
new Person();
（2）匿名对象的特点：
-------------------------------------创建匿名对象直接使用，没有变量值
new Person().eat() //eat方法被一个没有名字的Person对象调用了。
--------------------------------------匿名对象在没有指定其引用变量是只能使用一次；
new Person().eat(); 创建一个匿名对象，调用eat方法 new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象
-------------------------------------匿名对象可以作为方法返回值和方法接受的参数
public class Person { public void eat(){ System.out.println("吃饭"); } public Person get(){ return new Person(); //匿名对象可以直接当返回值使用也可以当参数 } }
public class Test { public static void main(String[] args) { //匿名对象：只能使用一次 new Person().eat(); } }
2、内部类
（1）概述：
定义：将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
什么时候使用内部类？
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。
class 汽车 { //外部类 class 发动机 { //内部类 } }
内部类分类：成员内部类与局部内部类。
成员内部类：成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
格式：
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
举例说明：
public class Outer { int num=1; class Inner{//=============================================成员内部类 int num=2; public void in(){ int num=3; System.out.println("这是成员内部类"); System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); } } }
public class Test { public static void main(String[] args) { Outer.Inner oi=new Outer().new Inner();//===================外部类名。内部类名 变量名=new 外部类名（）。new内部类名 oi.in();//========================调用成员内部类中的方法 } }
局部内部类：定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
格式：
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
访问方式：
在外部类方法中，创建内部类对象，进行访问
举例说明下：
public class Outer { public void out(){ //局部内部类，写在方法里面 class Inner{ public void in(){ System.out.println("这是局部内部类"); } } Inner in=new Inner(); in.in(); } }
public class Test { public static void main(String[] args) { Outer outer=new Outer();//访问内部类创建一个对象，直接用对象调用外部类的方法 outer.out(); } }
（2）内部类的实际使用---------匿名内部类
内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。
最常用到的内部类就是匿名内部类，它是局部内部类的一种。
定义的匿名内部类有两个含义：
-----------------临时定义某一指定类型的子类
-----------------定义后即刻创建刚刚定义的这个子类的对象
定义匿名内部类的作用及格式：
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口(){
//进行方法重写
};
代码例子：
//已经存在的父类： public abstract class Person{ public abstract void eat(); } //定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量 Person p = new Person(){ public void eat() { System.out.println(“我吃了”); } }; //调用eat方法 p.eat();
使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：
new Person(){ public void eat() { System.out.println(“我吃了”); } }.eat();
3、包的声明与访问
（1）概述：
java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。
当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。
在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。
（2）包的定义：
通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接
类中包的声明格式：
package 包名.包名.包名…;
如：Oracle网址oracle.com那么网址反写就为com.oracle
注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）
代码演示：
package com.oracle; //包的声明，必须在有效代码的第一行 import java.util.Scanner;//---------------导包 import java.util.Random; public class Demo {}
（3）包的访问
在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。
包名.包名….类名
如： java.util.Scanner
java.util.Random
com.oracle.Demo
带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
com.oracle.Demo d = new com.oracle.Demo();
前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。
类的简化访问
当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。
如：com.oracle包中有两个类，PersonTest类，与Person类。我们在PersonTest类中，访问Person类时，由于是同一个包下，访问时可以省略包名，即直接通过类名访问 Person。
类名 变量名 = new类名();
Person p = new Person();
当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。
package com.oracle02;
public class Person {}
可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。
导包的格式：
import 包名.类名;
当程序导入指定的包后，使用类时，就可以简化了。演示如下
//导入包前的方式 //创建对象 java.util.Random r1 = new java.util.Random(); java.util.Random r2 = new java.util.Random(); java.util.Scanner sc1 = new java.util.Scanner(System.in); java.util.Scanner sc2 = new java.util.Scanner(System.in); //导入包后的方式 import java.util.Random; import java.util.Scanner; //创建对象 Random r1 = new Random(); Random r2 = new Random(); Scanner sc1 = new Scanner(System.in); Scanner sc2 = new Scanner(System.in);
import导包代码书写的位置：在声明包package后，定义所有类class前，使用导包import包名.包名.类名;
4、访问修饰符
1、访问修饰符
|
public |
protected |
default |
private |
|
|
同一类中 |
√ |
√ |
√ |
√ |
|
同一包中(子类与无关类) |
√ |
√ |
√ |
|
|
不同包的子类 |
√ |
√ |
||
|
不同包中的无关类 |
√ |
在日常开发过程中，编写的类、方法、成员变量的访问
要想仅能在本类中访问使用private修饰；
要想本包中的类都可以访问不加修饰符即可；
要想本包中的类与其他包中的子类可以访问使用protected修饰
要想所有包中的所有类都可以访问使用public修饰。
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
5、代码块
（1）局部代码块
局部代码块是定义在方法或语句中
特点：
以”{}”划定的代码区域，此时只需要关注作用域的不同即可
方法和类都是以代码块的方式划定边界的
class Demo{ public static void main(String[] args) { { int x = 1; System.out.println("普通代码块" + x); } int x = 99; System.out.println("代码块之外" + x); } }
（2）构造代码快
构造代码块是定义在类中成员位置的代码块
l 优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
l 每创建一个对象均会执行一次构造代码块。
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); } }
（3）静态代码块
特点：
它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
该类不管创建多少对象，静态代码块只执行一次。
可用于给静态变量赋值，用来给类进行初始化。
静态代码块是定义在成员位置，使用static修饰的代码块。
public class Person { private String name; private int age; //静态代码块 static{ System.out.println("静态代码块执行了"); } }