1、匿名对象
概念：是指只有创建对象语句，但是没有把对象赋值给某个变量
例：创建一个匿名对象
new Person();
特点：
（1）、创建对象可以直接用，没有变量名
（2）、匿名对象没有指定变量名的时候，只能使用一次
（3）、匿名对象可以作为方法接受参数、方法返回值使用
例：创建一个Person类
public class Person {
private String name;
private int 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 Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
}
}
创建一个测试类
public class Demo01 {
public static void main(String[] args) {
new Person().getName();
get(new Person());
}
public static Person get(Person P){
return new Person();
}
}
2、内部类
概念：写在其他类的内部，写在类内部的类叫做内部类，其他的可以叫做外部类。可以写在其他类的成员位置和局部位置，这些局部位置叫局部内部类，成员位置叫成员内部类（其实就是一个正常定义类的过程，包括修饰符继承实现的关系等，在内部类中可以直接访问外部类所有成员）
（1）成员内部类
类似类中的成员变量。
创建格式：
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
访问格式：
外部类.内部类 变量名=new 外部类（）.new 内部类（）；
例：创建一个Outer类，内写一个内部类Inner
//外部类
public class Outer {
int a=1;
//内部类
class Inner{
int a=2;
public void in(){
int a=3;
System.out.println(a);//3局部变量
System.out.println(this.a);//2内部类变量
System.out.println(Outer.this.a);//1外部类成员变量
}
}
}
创建一个测试类
public class Demo02 {
public static void main(String[] args) {
Outer.Inner oi=new Outer().new Inner();
oi.in();
}
}
（2）局部内部类
局部内部类定义在类中的方法中的类，类似方法中的局部变量
定义格式：
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
例：创建一个outer类写一个局部内部类
public class Outer {
public void out(){
class Inner{
public void in(){
System.out.println("这是内部类方法");
}
}
Inner i=new Inner();
i.in();
}
}
注：上述中的Inner写在了out方法内，所以是个局部内部类，此时只能在这个方法中才能够访问到这个局部内部类，测试时，可以通过创建Outer对象来调用这个out方法 达到访问的目的
3、内部类的实际应用--匿名内部类
概念：定义某一指定类型的子类，定义后即可创建这一子类对象
作用：匿名内部类是创建某个子类对象的快捷方式
格式：
new 父类或接口{
重写的方法
}；
例：创建一个接口
public interface Smoking {
public abstract void smoke();
}
创建一个测试类，创建这个接口的子类对象，并且调用方法
public class Demo02 {
public static void main(String[] args) {
new Smoking(){
public void smoke() {
System.out.println("学生抽烟");
}
}.smoke();
}
}
注：既然他是个子类对象，就可以通过.方法名来调用这个方法。
如果这个smoking接口中有两个方法，那我创建子类的时候重写两个方法，怎样实现这两个方法 的调用呢
代码演示
public interface Smoking {
public abstract void smoke();
public abstract void drink();
}
注：此刻这个接口中我创建了两个方法
public class Demo02 {
public static void main(String[] args) {
//多态
Smoking s=new Smoking(){
public void smoke() {
System.out.println("学生抽烟");
}
public void drink() {
System.out.println("学生喝酒");
}
};
s.smoke();
s.drink();
}
}
注：我创建的是一个子类对象，我将这个子类对象赋值给父类引用的变量名s,(即，父类引用变量，指向子类对象)这就是运动了多态
4、包
概念，包其实就是文件夹，包里存放的是类文件夹
类中包的声明格式：
package 包名.包名.包名；例：package com.orcale.demo02;
包的反问格式
包名.包名...类名 例：java.util.Scanner；
导包格式：
import 包名.包名..类名 例：import java.util.Scanner；
5、访问修饰符
java中右四大访问修饰符：public protected default（这个是默认的不写）private；
public ：在同一类中，同一包中（包含子类，无关类），不同包的子类，不同包的无关类 都可以访问到
protected：在同一类中，同一包中（包含子类，无关类），不同包的子类。可以访问
default：这个是不写的修饰符。只能在同一类中，在同一包中（包含子类，无关类）可以访问
private ：只能在本类中才能访问
例：创建一个A类
public class A {
private int a=1;
protected int b=2;
int c=3;
public int d=4;
public void a(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
注：这四种类型，在本类中都可以被访问到
创建一个B类与A在同一个包下，继承A类，再分别访问一下这四个类型
public class B extends A {
public void get(){
//System.out.println(a);a是私有权限 只能在本类中访问
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
注：只有a被private修饰，所以在同一包中（包含子类，无关类）除了私有权限不能被访问外，其他都能访问到
创建一个C类，与A，B 不同包，再来访问一下这四个类型
import com.orcale.demo03.A;
public class C extends A {
public void get(){
//System.out.println(a);a是私有权限 只能在本类中访问
System.out.println(b);
//System.out.println(c);默认权限只能在本包中访问
System.out.println(d);
}
}
注：首先a有私有权限不能被访问，c是默认的default权限，其不能被不同包访问
创建一个D类与C同包，但与C，A B都没有关系
import com.orcale.demo03.A;
public class D {
public void get(){
//System.out.println(a);a是私有权限 只能在本类中访问
//System.out.println(new A().b);//受保护权限
//System.out.println(c);默认权限只能在本包中访问
System.out.println(new A().d);
}
}
注：首先a有私有权限不能被访问，b,是受保护权限，不能被不同包的无关类访问c是默认的default权限，其不能被不同包访问
6、代码块
（1）局部代码块
局部代码块时定义在方法或者语句中的，以{}划定的代码区域，只需要关注作用域不同即可，方法和类都是利用代码块来划分界限的
例：
public class Demo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a=1;
{
int b=2;
System.out.println(a);
System.out.println(b);
}
System.out.println(a);
//访问不到里边的System.out.println(b);
}
}
注：在大括号外边访问不到大括号内部的b变量
（2）构造代码块
构造代码块定义在类的成员变量位置的代码块
优先于构造方法执行，用于执行所有对象均需要初始化的操作，每创建一个对象就会执行一次构造代码块
例：
public class Person {
//构造代码块
{
System.out.println("这是构造代码块");
}
public Person(){
System.out.println("这是构造方法");
}
}
public class Demo02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p=new Person();
Person p2=new Person();
}
}
运行结果为：
这是构造代码块
这是构造方法
这是构造代码块
这是构造方法
（3）静态代码块
写在类中成员变量的位置，用static关键字修饰
优先于构造方法试行，当以任意形式使用到该类时使用，无论创建多少个类对象，静态代码块只执行一次
例
public class Person {
//构造代码块
{
System.out.println("这是构造代码块");
}
public Person(){
System.out.println("这是构造方法");
}
//静态代码块 优先于构造代码块，以任意形式第一次使用到该类的时候执行
static{
System.out.println("这是静态代码块");
}
}
还是上方的测试类运行
这是静态代码块
这是构造代码块
这是构造方法
这是构造代码块
这是构造方法