1.包 （文件夹）

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。
在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

创新互联专注于企业全网整合营销推广、网站重做改版、云霄网站定制设计、自适应品牌网站建设、H5页面制作、成都做商城网站、集团公司官网建设、外贸网站制作、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为云霄等各大城市提供网站开发制作服务。

package （包） 指：类所在的包
import （引入包中的类）
引入在类中需要的类（我们写的程序就是一个类，import 的作用就是 在我们写程序的时候， 引入我们所需要的类）

import java.util.Arrays;// 导入包util包中的 Arrays 类
public class ObjectOrientedProgramming {public static void main(String[] args) {int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));
        在输入 Arrays 的途中，编译器会给出提示，只要我们选择就能自动导入对应包中的类。
        // Arrays 是一个类，而toString 由类 来调用的，说明toString 是一个静态方法 
        // 也就是说所有通过类调用的方法都是 静态的
    }
}

创建自定义的包

src–>New–>Package -->命名–>创建类
包的命名：倒置（且全小写）
在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包

2.封装 用关键字private进行封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

例如：计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

get和set函数

对封装后的类进行访问

class Person {private String name;
    private int age;
    public Person(String name, int age) {this.name = name;
        this.age = 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;
    }
 }

步骤：
鼠标右击 -->Generate–>Getter and Setter

还能快速生成构造方法

3.Static

static修饰的成员变量，称为静态成员变量，静态成员变量大的特性：不属于某个具体的对象，是所有对象所共享的。
【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁）

静态成员变量

访问静态成员变量：推荐Student类.classRoom

public class Student{public String name;
    public int  age;
    public static String classRoom = "107号房";
    public static void main(String[] args) {// 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        
        Student s1 = new Student("Li leilei", 18);
        Student s2 = new Student("Han MeiMei", 19);
        Student s3 = new Student("Jim", 18);
 
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
        }
  }

静态成员方法

【静态方法特性】

1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量（非静态访问非静态、非静态访问静态、静态访问静态）
4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用。

public static String getClassRoom(){System.out.println(this);
    return classRoom;
}
 
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
 
public static String getClassRoom(){age += 1;
    return classRoom;
}
 
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age
public static String getClassRoom(){doClass();//非静态成员方法
    return classRoom;
}
 
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

初始化

除下列1、2、3外，还可以用代码块给静态成员变量初始化。

4.代码块

1.本地代码块
2.实例代码块–>非静态代码块/构造块
3.静态代码块
4.同步代码块–>（多线程）

实例代码块

构造块：定义在类中、在方法之外的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

public class Student{//实例成员变量
    private String name;
    private  int age;    
    public Student() {System.out.println("I am Student init()");
    }
    
    //实例代码块
    {this.name = "csdn";
        this.age = 12;
        System.out.println("I am instance init()!");
    }
    
    public void show(){System.out.println("name: "+name+" age: "+age);
    }
} 
public class Main {public static void main(String[] args) {Student stu = new Student();
        stu.show();
    }
}
// 运行结果
I am instance init()
I am Student init()!
name: csdn age: 12

静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student {//实例成员变量
        private String name;
        private  int age;

        {System.out.println("I am Student init()");
        }

        // 静态代码块
        static {System.out.println("I am static init()!");
        }

        public Student(){System.out.println("I am Student init()!");
        }

        public static void main(String[] args) {Student s1 = new Student();
            Student s2 = new Student();
        }
    }

总结：
1. 静态代码块不管生成多少个对象，其只会执行一次
2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
4.实例代码块只有在创建对象时才会执行

5.对象的打印

如果想要默认打印对象中的属性该如何处理呢？
答：重写toString方法即可。

public class Person {String name;
    String gender;
    int age;
 
    public Person(String name, String gender, int age) {this.name = name;
        this.gender = gender;
        this.age = age;
    }
 
    @Override
    public String toString() {return "[" + name + "," + gender + "," + age + "]";
    }
 
    public static void main(String[] args) {Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}
 
// 输出结果：[Jim,男,18]

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

当前文章：javaSE(包、封装、static用法、代码块）-创新互联
链接URL：http://cdweb.net/article/dociej.html