1匿名对象
1.1定义
匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
1.2特点
1）直接使用，没有变量名
2）只能使用一次
这里面每个new都是不同的对象。
3）可以作为方法接收的参数、方法返回值使用
public class Test {
public static void main(String[] args) {
show1(new School()); //可以作为参数传递
}
public static void show1(School s){
s.age=10;
System.out.println("我的是"+s.age);
}
//作为返回值
public static School show2(){
return new School();
}
}
2 内部类
2.1定义
将类写在其他类的内部，也就是类中类。
在描述事物时，若一个事物内部还包含其他可能包含的事物，就可以用内部类。
但实际用的很少，知道有这么个概念就可以。
定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。
在内部类中可以直接访问外部类的所有成员。
内部类按照位置分为成员内部类和局部内部类
2.2成员内部类
定义：
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
访问：
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
例：
public class Outer {
private int i=0;
//成员内部类
class Inner{
int i=2;
public void show(){
int i=1;
System.out.println(i); //局部变量
System.out.println(this.i); //内部类成员变量
System.out.println(Outer.this.i); //外部类成员变量
}
}
}
public class Test {
public static void main(String[] args) {
Outer.Inner oi=new Outer().new Inner();
oi.show();
}
}
2.3局部内部类
定义：
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
访问：
在外部类方法中，创建内部类对象，进行访问
例：
//外部类
public class Outer {
public void show(){
//局部内部类
class Inner{
public void show2(){
System.out.println("这是局部内部类的方法");
}
}
Inner in=new Inner();
in.show2();
}
}
public class Test {
public static void main(String[] args) {
Outer out=new Outer();
out.show();
}
}
2.4匿名内部类
最常用到的内部类是匿名内部类，它是局部内部类的一种。
有的时候，对象和方法只用一次，不想再创建一个实现类，再重写里面方法，比较麻烦，就可以用匿名内部类对象。
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
New 父类{
重写父类方法
}.父类方法
Tips:
1）就是这种格式，记住就行。
2）注意必须要重写所有抽象方法。
3）一般开发者不会这样写，只是jdk会有一些接口就是这么写的，所以认识这种方式就可以。
4）还可以用多态接收一下，给匿名内部类对象起个名而已。就可以重复使用了，可以调多个方法。
例：
public interface Smoking {
public abstract void smoke();
}
public class Test {
public static void main(String[] args) {
new Smoking(){
public void smoke(){
System.out.println("抽烟1");
}
}.smoke();
//用多态实现，就可以多次用了
Smoking s=new Smoking(){
public void smoke(){
System.out.println("抽烟2");
}
};
s.smoke();
}
}
3包的声明与访问
java的包，其实就是电脑系统中的文件夹，包里存放的是类文件。
当类文件很多的时候，会采用多个包进行存放管理他们，这种方式称为分包管理。
在项目中，将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。
src里面是.java
bin里面是.class
3.1声明格式
通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接
格式：
package 包名.包名.包名…;
如：Oracle网址oracle.com，那么网址反写就为com.oracle
注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）
3.2导包
格式：
import包名.包名.类名;
例：import java.util.Scanner;
import java.util.Random;
如果不导包，就要这样写：java.util.Scanner sc=new java.util.Scanner(System.in);
太麻烦了，所以要导包。
如果用很多util里的包，可以java.util.*
import导包代码书写的位置：
在声明包package后，定义所有类class前
3.3包的访问
1）包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。
2）要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。
3）当要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。
4访问修饰符
在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，不同权限的访问能力：
|
public |
protected |
default |
private |
|
|
同一类中 |
√ |
√ |
√ |
√ |
|
同一包中(子类与无关类) |
√ |
√ |
√ |
|
|
不同包的子类 |
√ |
√ |
||
|
不同包中的无关类 |
√ |
总结：
1） public：任意
protected：本包，不同包的子类
default：本包（这里的default，就是不写任何修饰符，不是写一个“default”）
private：本类
2）无论修饰类，变量，方法，都是一样的。
3）如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
例：
package demo02;
public class A {
public int a=1;
protected int b=2;
int c=3; //这是default
private int d=4;
public void show(){
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
}
}
5代码块
5.1局部代码块
局部代码块是定义在方法或语句中。
特点：
1）以”{}”划定的代码区域，此时只需要关注作用域的不同即可
2）方法和类都是以代码块的方式划定边界的
例：
5.2构造代码块
构造代码块是定义在类中成员位置的代码块
特点：
1）优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
2）每创建一个对象均会执行一次构造代码块。
5.3静态代码块
静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
1）它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
2）该类不管创建多少对象，静态代码块只执行一次。
3）可用于给静态变量赋值，用来给类进行初始化。
例：
public class Person {
public Person(){
System.out.println("这是构造方法");
}
{
System.out.println("这是构造代码块");
}
static{
System.out.println("这是静态代码块");
}
}
public class Test2 {
public static void main(String[] args) {
Person p=new Person();
Person p2=new Person();
}
}
Tips：静态代码块进静态区，在main还没进栈时，就执行了。所以再创建对象，也不会再执行了。只执行一次。
常用于连接数据库。