代码块
1. 放在{ }中的代码
2. 分类:
局部代码块
静态代码块
构造代码块
同步代码块(线程)
局部代码块
1. 格式
{
}
2. 位置:在方法中
3. 作用:限定变量的生命周期和作用于,进队{}有用
注意:
如果在局部代码块中修改了局部代码块外声明的变量,
局部代码块结束之后,并不会消除局部代码块对这个变量的影响
代码:
/**
* 位置方法中,
* 作用:限定变量的生命周期
* 注意:如果在局部代码块中修改了局部代码块外声明的变量,
* 局部代码块结束之后,并不会消除局部代码块对这个变量的影响
* @author Administrator
*
*/
public class 局部代码块 {
public static void main(String[] args) {
A a=new A();
a.f();
}
}
class A{
public void f() {
{
int a=10;
System.out.println("这是代码块里的a:"+a);
}
int a=20;
System.out.println("这是代码块外的a:"+a);
}
}
输出结果:
静态代码块
1. 格式:
static{
}
2. 位置:类中方法外,加static关键字
3. 静态代码块随着类的加载而加载,加载一次。多个情况,按照代码的顺序执行。
4. 用法:
当类加载静态代码块就执行。
代码:
/**
* 位置:类中方法外
* 作用:用于给静态的成员变量初始化赋值
* 用于执行那些只需要执行一次的代码,例如驱动加载等
* 执行特点:
* 随着类的加载而执行
* 静态代码块只执行一次
* 执行的时机最早:早于所有的对象相关内容
* @author Administrator
*
*/
public class 静态代码块 {
public static void main(String[] args) {
B.f();
}
}
class B{
static {
int a=10;
System.out.println("这是静态代码块");
}
public static void f() {
System.out.println("这是静态方法");
}
}
输出结果:
构造代码块
1. 格式:
{
}
2. 位置:
类中方法外
3. 构造代码块随着构造函数的执行而执行,没调用一次构造函数,
就执行一次构造代码块。多次调用构造函数则按照代码的顺序执行。
4. 用法:
抽取出构造方法中共性的代码,可以放在构造代码块中。
代码:
/**
* 位置:类中方法外
* 作用:用于给成员变量初始化赋值,可以执行不同构造函数的共同功能
* 说明:
* 创建对象时执行,由JVM默认调用
* 在构造方法执行之前执行
* 任一构造方法前都执行一次
* Administrator
*
*/
public class 构造代码块 {
public static void main(String[] args) {
C c=new C();
C c1=new C(1);
}
}
class C{
{
System.out.println("这是构造代码块");
}
public C() {
System.out.println("这是无参构造函数");
}
public C(int a){
System.out.println("这是有参构造函数");
}
}
输出结果:
类的对象的加载顺序
1. 一个类的对象创建的历程:
1》先加载静态成员。
2》隐式三步:
①super
②显示初始化
③构造代码块
其中②③执行的顺序按照代码的顺序执行
3》构造方法中的代码。
2. 如果有继承关系,先父类 后子类,静态非静态分开。
代码:
/**
1.一个类的对象的创建过程:
1》先加载静态的成员。
2》 隐式三步:
① super
②显式初始化
③构造代码块
其中 ②③按照代码的顺序执行。多个的情况下,也是如此
3》构造方法中的代码。
2.如果有继承关系,先父类 后子类。静态/非静态分开。
*
*/
public class Topic1 {
public static void main(String[] args) {
new N(1);
}
}
class M {
static{
System.out.println("这是M的静态代码块。。。。。6");
}
{
System.out.println("这是M的构造代码块。。。。8");
}
}
class N extends M{
static{
System.out.println("这是N的静态代码块。。。。1");
}
{
System.out.println("这是一个构造代码块。。。。2");
}
int a=setN();
public N(int a) {
this();
System.out.println("这是N的有参构造。。。。4");
}
public N() {
System.out.println("这是N的无参构造。。。。3");
}
public int setN() {
System.out.println("这是a的赋值。。。。。5");
return 1;
}
}
输出结果:
内部类
1. 内部类:类中的类
2. 内部类的种类
①成员内部类:类中方法外
一般成员内部类
静态成员内部类
私有成员内部类
局部内部类:方法中
3. 内部类的命名规则:
外部类的名称$内部类的名称。
一般成员内部类
1. 位置:类中方法外
2. 在外部类中不能直接使用内部类的成员,想要使用,需要创建内部类对象才能调用
3. 在内部类中能直接调用外部类的成员
4. 一般成员内部类创建对象的格式
外部类名称.内部类名称 对象名=new 外部类名称(参数).new 内部类名称(参数)
5. 一般成员内部类不能有静态方法。静态方法只能存在静态内部成员类或外部类。
代码:
/**
* 1.位置 :类中方法外。
2.在外部类中不能直接使用内部类的成员,要想使用,需要创建内部类的对象,才能调用。
3.在内部类中可以直接使用外部类的成员
4.一般成员内部类:对象创建:
格式:
外部类的名称.内部类的名称 对象的名称= new 外部类的名称(参数).new 内部类的名称(参数)
* @author Administrator
*
*/
public class 一般成员内部类 {
public static void main(String[] args) {
OuterC.InnerC inner=new OuterC().new InnerC();
inner.fun();
System.out.println(inner.a);
}
}
class OuterC{
int f=20;
public void outerFun() {
System.out.println("这是外部类的一个方法");
/*InnerC in=new InnerC();
in.a=10;
in.fun();*/
}
class InnerC{
int a=19;
public void fun() {
/*outerFun();
f=10;*/
System.out.println("这是一个内部类");
}
}
}
输出结果:
静态成员内部类
1. 位置:类中方法外。多了一个static
2. 外部类不能直接调用内部类的成员,如果是静态则类名.成员名称进行调用,如果是非静态成员则需创建对象。
3. 静态成员内部类的成员可以调用外部类的成员:
①外部类成员是静态时,直接调用。
②外部类成员是非静态时,创建对象再调用。
4. 对象的创建:
格式:
外部类名称.内部类名称 对象名=new 外部类名称.内部类名称()
代码:
/**
1.位置: 类中方法外。多了一个关键字static
2.外部类不能直接调用静态成员内部类的成员,对于静态成员来说,类名.成员进行调用,如果是静态成员内部类的非静态成员,需要创建对象,再调用。
3.静态成员内部类的成员可以调用外部类的成员:
① 外部类的成员是静态成员时,直接调用。
②外部类的成员是非静态成员时,创建对象,再进行调用。
4.对象的创建:
格式:
外部类的名称.内部类的名称 对象的名称=new 外部类的名称.内部类的名称()
*
*/
public class 静态成员内部类 {
public static void main(String[] args) {
OuterS.InnerS inners=new OuterS.InnerS();
}
}
class OuterS{
int a=10;
static int b=20;
public static void sf() {
System.out.println(InnerS.d);
InnerS.innerSF();
}
public void fun() {
}
//静态成员内部类
static class InnerS{
int c=30;
static int d=50;
public void innerFun() {
sf();
System.out.println(b);
System.out.println("这是一个静态成员内部类的方法");
OuterS os=new OuterS();//对于外部类中的非静态成员,必须创建对象 保证存在
os.fun();
}
public static void innerSF() {
sf();
System.out.println(b);
System.out.println("这是一个静态成员内部类的静态方法。。。。。");
OuterS os=new OuterS();//对于外部类中的非静态成员,必须创建对象 保证存在
os.fun();
}
}
}
私有成员内部类
1. 位置:类中方法外,关键字private
2. 外部类不能直接调用私有成员内部类的成员:
1>如果外部类的成员是静态成员,先创建外部类的对象,
然后再创建私有成员内部类的对象,然后调用。
2>如果外部类成员是非静态成员,直接创建内部类对象,然后调用。
3. 私有成员内部类直接调用外部类的成员。
4. 对象的创建:
私有成员内部类,不能在外部类的外面创建对象。
5. 私有成员内部类没有静态方法。
代码:
public class 私有成员内部类{
public static void main(String[] args){
}
}
class OuterP {
public static void sf() {
// 为了保证内部类的必然存在,必须现有外部类,然后再有内部类的对象。
InnerP innerP = new OuterP().new InnerP();
innerP.funInner();
}
public void fun() {
InnerP innerP = new InnerP();
}
// 私有成员内部类
private class InnerP {
// 只有静态成员内部类有静态方法。
// public static void sfp() {}
public void funInner() {
fun();
sf();
System.out.println("这是一个内部类的方法。。。。。");
}
}
}
局部内部类
1. 局部内部类:
位置:在方法中
2. 局部内部类要想运行,必须先调用该局部内部类所在的方法,并且在方法中,创建对象,调用局部
内部类中的方法,才能使用。
代码:
public class 局部内部类 {
public static void main(String[] args) {
OuterT ot = new OuterT();
ot.fun();
}
}
class OuterT {
public void fun() {
class InnerT {
public void funT() {
System.out.println("这是一个局部内部类。。。。");
}
}
// 创建对象
InnerT in = new InnerT();
in.funT();
}
}