静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。

需要注意：

1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，

3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问

方法的重写

                                       Java中的访问修饰符

                 访问修饰符——可以修饰属性和方法的访问范围

                 访问修饰符的总结：

                  访问修饰符private 只能在本类中访问和使用

                  访问修饰符默认  只能在当前类和同一包中使用

                  访问修饰符protected 在本类、包中、子类中都可以使用

                  访问修饰符public 在任意一个位置来访问

Java 中的方法内部类

Java 中的静态内部类

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

//外部类
public class HelloWorld{
//外部类中的静态变量score
private  static int score=84;
//创建静态内部类
public static class SInner{
//内部类中的变量
int score=91;
public void show(){
System.out.println("访问外部类中的score:"+HelloWorld.score);
System.out.println("访问内部类中的score:"+score);}}
//测试静态内部类
public static void main(String []args){
//直接创建内部类的对象
SInner si=new SInner();
//调用show方法
si.show();}}

                                 Java中的包

    1.包的作用：

           管理java文件

           解决同名文件冲突

      2.定义包：package 包名

         注：必须放在java源程序的第一行 包名间可以使用“.”号隔开

                eg:com.imooc.MyClasss

       3.系统中的包

          java.（功能）.（类）

          java.lang.（类）包含java语言基础的类

          java.util.（类）java语言中各种工具类

          java.io.（类）包含输入、输出相关功能的类

      4.包的使用

          （1）可以通过import关键字，在某个文件使用其它文件中的类。

                   import com.imooc.music.MuClass

            （2）java中，包的命名规范是全小写字母拼写

            （3）使用的时候不但可以加载某个包下的所有文件

                     eg:com.imooc.*

                     也可以加载某个具体子包下 的所有文件

                     eg:com.imooc.music.*

//外部类HelloWorld
public class HelloWorld{
//外部类的私有属性name
private String name="imooc";
//外部类的成员属性
int age=20;
//成员内部类
public void Inner{
String name="我爱你";
public void show(){
System.out.println("外部类中的name:"+HelloWorld.this.name);
System.out.println("内部类中的name:"+name);
System.out.println("外部类的age:"+age);}}
public static void main(String[]args){
HelloWorld o=new HelloWorld();
Inner inn=0.new Inner();
inn.show();}
}

                                           面向对象特性

         面向对象三大特性：封装、继承、多态

                                             封装

1.概念：

    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

2.好处：

   a.只能通过规定的方法访问数据

   b.隐藏类的实例细节，方便修改和实现

3.封装的实现步骤

                           修改属性的可见性 （设为private）

                            创建getter/setter方法 （用于属性的读写）

                            在getter/setter方法中加入属性控制语句 （对属性的合法性进行判断）

//外部类HelloWorld
public class HelloWorld{
//内部类Inner,类Inner在类HelloWorld的内部
public class Inner{
//内部类的方法
public void show(){
System.out.println("Welcome to GuangZhou");
}}
public static void main(String[]args){
//创建外部类对象
HelloWorld hello=new HelloWorld();
//创建内部类对象
Inner  i=hello.new Inner();
//调用内部类对象的方法
i.show();}}

java的四种基本数据类型 ：byte，short，int，long

java this关键字 1.this关键字代表当前对象 this.属性 操作当前对象的属性 this.方法 调用当前对象的方法 2.封装对象的属性的时候，经常会使用this关键字 public void setJia(double jia){ this.jia=jia;//this.属性=参数；就是将参数的值付给当前对象的属性（为了区分属性和参数） this.sendMessage();//this.方法；就是调用当前对象的sendMessage（）方法。 }

private 同类 默认 同类 同包 protecte 同类 同包 子类 public 同类 同包 子类 其他

1、静态方法调用同类的静态成员，无法直接调用非静态成员。

比如：

static String hobby = "imooc";

String name = "慕课网";

public static void print(){

可以调用hobby

(如果要调用非静态name，则要搞一个对象，则           对象.name，才可以调用。)

}

2、普通成员方法（public void show()），直接调用同类的非静态和静态变量。

3、静态方法不能调用非静态方法，

      静态方法 调用静态方法

public void show(){}

public static void print(){}

public static void main(String[] args){

print();

}