08 java基础课程-内部类, 初始化,包,访问修饰符

使用包中的类
package com.ourchr; public class Test{ private int m; int n; protected int x; public int y; }

javac com\ourchr\Test.java

java com.ourchr.Test
}
对象的初始化顺序： 1. 从顶级父类开始加载，每个类加载后执行其static 代码块 2. 从顶级父类的构造方法开始执行，如果某个类有 非静态初始化代码块，先执行这个代码块再执行 构造方法内的语句。

包是类库的组成单元, Java的类库是由各种各样功 能包组成的.
◦ Java安装目录jre\lib\rt.jar就是java的类 库
}
}


静态内部类就是把这个类定义为外部类的静态成员， 在静态内部类内只能访问外部类的静态成员。 如果从外部实例化一个类的静态内部类，不必先实 例化外部类，如： Outer.StaticInner sin = new Outter.StaticInner();
class MyOutter3 { private static int num = 100; static class StaticInner { private static int num = 200; public void show() { System.out.println("MyOutter3.num=" + MyOutter3.num); System.out.println("StaticInner.num=" + num); } }
private
只有该类可以访 问
Q&A
} class Test2 { public static void main(String[] args) { MyOutter3.StaticInner sin = new MyOutter3.StaticInner(); sin.show(); } }


匿名内部类是最常用的一种内部类形式，在临时 创建一个内部类对象时比较方便，不必单独去定 义这个类，可以对一个类、抽象类、接口进行重 写并创建对象。 由于匿名内部类没有名字，所以不能重用这个对 象 创建形式： new MyType() { //重写某些方法 };
class MyOutter2 { private int count = 1000; public void testInner() { System.out.println("test inner class"); Inner in = new Inner(); in.show(); } class Inner { private int count = 2000; public void show() { System.out.println("MyOutter2.count=" + MyOutter2.this.count); System.out.println("Inner.count=" + this.count); } } } class Test2 { public static void main(String[] args) { MyOutter2 out2 = new MyOutter2(); out2.testInner(); MyOutter2.Inner in = out2.new Inner(); in.show();
内部类, 初始化，包，访问修饰符

内部类 类及对象的初始化 包的定义与引用 访问修饰符

内部类：在一个类的成员声明部分定义的一个类或 一个类的某个方法内定义的类。 内部类分为三种类型：
◦ 普通内部类 ◦ 静态内部类 ◦ 匿名内部类


普通内部类就是把这个类作为一个外部类的实例成员或方 法内的局部成员类。 在普通内部类中可以访问外部类的所有成员，包括 private成员。 如果普通内部类覆盖了外部类的成员，可通过”外部类 名.this.成员”方式调用外部类的成员。 如果在外部去创建普通内部类的对象，必须先实例化外部 类，通过外部类对象才能实例化内部类，如: Outter out = new Outter(); Outter.Inner in = out.new Inner(); 普通内部类通常声明为private，不建议从外部访问

class T{ static{System.out.println(1); } T(){ System.out.println(2); } } } new T(); //使用T类需要先加载T类，加载后会立刻执行 static代码块，创建对象时才会执行构造方法
在创建对象时除构造方法被执行外还有一段代码会 自动执行 class T{ { //初始化代码块，在执行构造方法内的代码前 执行 } } new T();
在访问一个类的静态属性或方法时，或构造一个类 的实例时，虚拟机需要从外部加载这个类文件，加 载完毕后，有一部分代码会自动执行 class T{ static{ //静态初始化代码块，在类加载后执行 } } 注：无论一个类被调用几次或实例化几个对象， static静态初始化块最多只被初始化一次

我们可以在静态代码块中初始化类的静态属性 class T{ static int dbURL; //连接数据库的地址 因为每个工程一般只会连接 static{ 到一个数据库，数据库地址 跟对象无关，所以这里定义 dbURL = … ; 为static类型 //从文件中读取数据库地址，这样可以在外部改变 dbURL，而不用重新编译java代码； } }

class T{ { System.out.println(1); } T(){ System.out.println(0); } } new T(); //思考打印结果
思考执行new TT()时打印结果 class T{ static{ System.out.println(“T0”); } { System.out.println(“T1”); } T(){ System.out.println(“T2”); } } class TT extends T{ static{ System.out.println(“TT0”); } { System.out.println(“TT1”); } TT(){ System.out.println(“TT2”); } }
如果A类依赖于B类，则先加载B类 class A extends B{ static{System.out.println(2); } } class B{ static{System.out.println(1); } } new A();

Hale Waihona Puke 在程序的一次运行过程中，类只会被加载一次，所 以一个类的静态代码块也不会执行两次 class T{ static{System.out.println(1); } } new T(); new T();

在调用类的构造方法时，系统总是默认先调用其父 类的构造方法，直到到达Object class T{ T(){} } class TT extends T{ TT(){//系统先调用父类构造方法, super()} }

以下代码是否存在错误？ class T{ T(int a){} //T() {} } class TT extends T{

类和接口是包的组成元素, 编程人员可以把一组类 和接口通过package关键字封装在一个包中，从而 实现了Java的命名空间。

声明包
◦ 在源文件的开始加上：package 包名(要求全部小写)(反域 名制) package com.sun; 注：package语句必有位于类文件的有效代码的首行位置。 ◦ 如使用不同包的类，必须加入import关键字 ◦ 引用的包必须在classpath环境变量中，如果不在，运行时 要用-classpath参数单独指定.
interface NoiseMaker { void makeNoise(); } class MyOutter4 { public void testAnonymousInnerClass() { NoiseMaker maker = new NoiseMaker() { public void makeNoise() { System.out.println("咚咚咚。。。"); } }; maker.makeNoise(); } } class Test2 { public static void main(String[] args) { MyOutter4 out4 = new MyOutter4(); out4.testAnonymousInnerClass(); } }
注意当前目录必须为com的父级目录

类
◦ public 可以跨包使用 ◦ 缺省 只允许在包中使用

成员
◦ ◦ ◦ ◦ public protected 缺省 private
public
该类或非该类均 可访问
protected
该类及其子类的 成员可以访问， 同一个包中的类 也可访问
默认
相同数据包中的 类可以访问