匿名对象：
匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址赋值给某个变量,主要用于参数传递。
匿名对象的特点：
public class Demo04 {
public static void main(String[] args) {
new Person(); 1：创建匿名对象直接使用，没有变量名。
new Person().sleep();
get(new Person());
}
public static void get(Person p){
p.sleep(); 2：匿名对象在没有指的其引用变量时，只能使用一次。
}
public static Person get2(){
return new Person(); 3：匿名对象可以作为方法接受的参数，方法返回值使用。
}
}
内部类：
概念：
将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
1：成员内部类：定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问。
访问方式：外部类名.内部类名 变量名=new 外部类名(). new 内部类吗();
//外部类
public class Outer {
int a=1;
public void Out(){
System.out.println("外部类方法");
//成员内部类
class Inner{
int b=2;
int a=3;
public void in(){
int a=4;
System.out.println(a); 访问局部变量a
System.out.println(this.a); 访问成员内部类a
System.out.println(Outer.this.a); 访问外部类的成员a
}
}
}
public class Demo01 {
public static void main(String[] args) {
//内部类对象
//外部类类名.内部类类名. 变量名=new 外部类类名（）.new 内部类类名（）
Outer.Inner oi=new Outer().new Inner();
System.out.println(oi.b);
oi.in();
}
}
2:局部内部类：定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问。
访问方式：在外部类方法中，创建内部类对象，进行访问。
public class Outer {
public void out(){
System.out.println("外部类方法");
//局部内部类
class Inner{
public void in(){
system.out.println("内部类方法");
}
}
//创建内部类对象
Inner in=new Inner();
in.in();
}
}
public class Demo01 {
public static void main(String[] args) {
new Outer().out(); 调用方法
}
}
匿名内部类概念：
最常用到的内部类就是匿名内部类，它是局部内部类的一种。
含义：
1： 临时定义某一指定类型的子类。
2：定义后即刻创建刚刚定义的这个子类的对象。
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口(){
//进行方法重写
}
代码体现：
接口：
public interface Smoking {
public abstract void smoke();
public abstract void drink();
}
类：
public class Student implements Smoking{
public void smoke(){ 重写smoke方法
System.out.println("学生抽烟");
}
}
测试类：
public class Demo02 {
public static void main(String[] args) {
Smoking s=new Student(); 多态
s.smoke(); 调用方法
匿名内部类：实现了快速创建某个类的子类，重写方法，并创建这个子类对象
Smoking s2=new Smoking(){
public void smoke() { 可以右键直接点出来方法
System.out.println("工人抽烟");
}
}.smoke(); 最终实现的是父类或子类的对象，没有名字，因为是对象，可以直接调用方法，.smoke();
}
}
若子类中有多个方法，可以多次调用
Smoking s2=new Smoking(){ 多态 父类对象变量指向子类对象。
public void smoke() {
System.out.println("工人抽烟");
}
};
public void drink() {
System.out.println("工人喝酒");
}
};
s2.drink();
s2.smoke();
}
}
包的声明格式：
通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接
package 包名.包名.包名…;
声明包的语句，必须写在程序有效代码的第一行（注释不算）
访问修饰符：
在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：
|
public |
protected |
default |
private |
|
|
同一类中 |
√ |
√ |
√ |
√ |
|
同一包中(子类与无关类) |
√ |
√ |
√ |
|
|
不同包的子类 |
√ |
√ |
||
|
不同包中的无关类 |
√ |
1：要想只能在本类中访问，使用private访问。
2：要想本类包的类都可以访问不加修饰符即可。（default）
3:要想本包中的类与其它包中的子类可以访问，使用protected访问。
4：要想本包中的类都可以访问，使用public修饰。
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
代码块：
1：局部代码块：局部代码块定义在方法或语句中。
public class Demo01 {
public static void main(String[] args) {
int a=1;
//局部代码块
{
int b=2;
System.out.println(b);
}
System.out.println(a);
}
}
2：构造代码块：定义在类中成员位置的代码块，优先于构造方法执行，用于执行所有对象均需要的初始化动作，每创建一次对象就会执行一次构造代码块。
3：静态代码块：定义在成员位置，使用static修饰的代码块，优先于主方法执行，优先于构造代码块执行，当以任意形式使用到该类时执行，该类不管创建多少对象，代码块只执行一次。可用于给静态变量赋值，用来给类进行初始化。
public class Demo02 {
public static void main(String[] args) {
new Person();
new Person();
}
}
public class Person {
public Person(){
System.out.println("构造方法");
}
//构造代码块
{
System.out.println("构造代码块");
}
//静态代码块
static{
System.out.println("静态代码快");
}
}