目录
四，构造方法
1.什么是构造方法
2.构造方法的特性
3.默认初始化
五，封装
1.什么是封装
2.访问限定符
六，封装扩展之包
1.什么是包
2.导入包中的类
【注意】
3.自定义包
（1）基本规则
（2）操作步骤
（3）包的访问权限控制举例
（4）常见的包
七，static成员
1.静态成员变量
（1）特性
（2）举例
2.静态成员方法
（1）特性
（2）举例
（3）静态成员变量初始化
八，代码块
1.什么是代码块
（1）普通代码块
（2）构造代码块（实例代码块）
（3）静态代码块
【注意】
九，内部类
1.什么是内部类
2.内部类的分类
（1）实例内部类（static未修饰）
（2）静态内部类（static修饰）
（3）局部内部类（了解）
（4）匿名内部类
十，对象的打印
使用idea时发现的小技巧
可以用来整理乱掉格式，使代码美观
删掉最后一个“{”，在补回去，代码自动整理
四，构造方法
1.什么是构造方法
构造方法(构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，只调用一次。
public class Date {
public int year;
public int month;
public int day;
public Date(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Date(int,int,int)方法被调用了");
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
// 此处创建了一个Date类型的对象，并没有显式调用构造方法
Date d = new Date(2021,6,9);
d.printDate(); // 2021-6-9
}
}
2.构造方法的特性
1.名字与类名相同，没有返回值类型，设置为void也不行
2. 一般情况下使用public修饰
3. 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
4.构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。
5.构造方法可以重载。
public Date(){
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
6.没有定义任何构造方法，编译器会默认生成一个无参的构造方法。
public class Date {
public int year;
public int month;
public int day;
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
7.构造方法中，可以通过this调用其他构造方法来简化代码
注意：this(...)必须是构造方法中第一条语句，且不能形成环
3.默认初始化
public class Date {
public int year;
public int month;
public int day;
public Date(int year, int month, int day) {
// 成员变量在定义时，并没有给初始值, 可以直接使用
System.out.println(this.year);
System.out.println(this.month);
System.out.println(this.day);
}
}
public static void main(String[] args) {
// 局部变量没有定义初始值，不能直接使用
int a=0;//若省去此处，编译错误
//只初始int a;也不能成功编译
System.out.println(a);
Date d = new Date(2021,6,9);
}
在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：
1. 检测对象对应的类是否加载了，如果没有加载则加载
2. 为对象分配内存空间
3. 处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4. 初始化所分配的空间
5. 设置对象头信息
6. 调用构造方法，给对象中各个成员赋值
五，封装
1.什么是封装
1.面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。
2.概念
客观：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互
主观：简单来说就是套壳屏蔽细节，例如你的电脑，你不需要了解其内部CPU等部件，只需要会使用即可。
2.访问限定符
1.Java中主要通过类和访问权限来实现封装：
类：将数据以及封装数据的方法结合在一起
访问权限：控制方法或者字段能否直接在类外使用。
2.四种访问权限
private:私有的，自用的
default:默认，预设 （什么都不写时的默认权限）
protected:受保护的（主要用在继承中，继承部分详细介绍）
public:公共的
public class Computer {
private String cpu; // cpu 只能在Computer类中使用
public String screen; // 屏幕
String brand; // 品牌---->默认default属性
public Computer(String brand, String cpu, String screen) {
this.brand = brand;
this.cpu = cpu;
this.screen = screen;
}
}
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "13*14");
System.out.println(p.screen);
// public属性： 可以任何其他类访问
// System.out.println(p.cpu);
// private属性：只能在Computer类中访问，不能被其他类访问，所以注释掉了
System.out.println(p.brand);
// default属性：只能被本包中类访问
}
}
六，封装扩展之包
1.什么是包
1.目的：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。
2.包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，类似于建文件夹，将相同的类放入一个文件夹中
3.在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。
2.导入包中的类
1.使用 import语句导入java.util包.
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
如果不用import,就需要冗余的这样写
java.util.Date date = new java.util.Date();
2.如果需要使用 java.util 中的其他类, 可以使用 import java.util. * ，但不建议这样，有出现类名冲突的风险，建议写明需要的类名
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
// 编译
3.可以使用import static导入包中静态的方法和字段。
【注意】
import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.
import 只是为了写代码的时候更方便.
import 更类似于 C++ 的 namespace 和 using
3.自定义包
（1）基本规则
1.在文件的最上方加上一个 package 语句指定该代码在哪个包中.
2.包名需要尽量指定成唯一的名字, 通常会用公司域名的颠倒形式(例如 com.bit.demo1 ).
3.包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径，com/bit/demo1 来存储代码.
4.如果一个类没有 package 语句, 则该类被放到一个默认包中.
（2）操作步骤
1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
2. 在弹出的对话框中输入包名, 例如 com.bao.demo1
3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.
4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了
5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句
（3）包的访问权限控制举例
Computer类位于com.bit.demo1包中
package com.bit.demo1;
public class Computer {
private String cpu; // cpu
public String screen; // 屏幕
String brand; // 品牌
public Computer(String brand, String cpu, String screen) {
this.brand = brand;
this.cpu = cpu;
this.screen = screen;
}
}
TestComputer类位置com.bit.demo2包中
package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "13*14");
System.out.println(p.screen);
// System.out.println(p.cpu); // 报错： cup是私有的，不允许被其他类访问
// System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
}
}
// 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败
（4）常见的包
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编程开发包。
七，static成员
1.静态成员变量
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员。
（1）特性
1.其不属于某个具体的对象，是所有对象所共享的。
2.既可以通过对象名（Student sc=new Student();中的sc）访问，也可以通过类名(public class Student(){ }中的Student)访问，但一般更推荐使用类名访问。
3.生命周期伴随类的一生。(即：随类的加载而创建，随类的卸载而销毁）
4.类变量存储在方法区当中
转载自——子翊寒
想了解什么是方法区——》http://t.csdn.cn/UGKWM
（2）举例
public class Student{
public String name;
public static String classRoom = "Bit306";
public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问
System.out.println(Student.classRoom);
Student s1 = new Student("Li leilei");
Student s2 = new Student("Han MeiMei");
Student s3 = new Student("Jim");
// 也可以通过对象访问：但是classRoom是三个对象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}
但是，静态成员变量一般都设置成private,就不能用以上方法来调用静态成员变量了，由此，静态成员方法闪亮登场！
2.静态成员方法
在java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。
（1）特性
1.不属于某个具体的对象，是类方法，可以直接通过类名调用（也可以通过对象名调用）。
2.静态方法中不能访问任何非静态成员变量
3.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
4.静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
（2）举例
public class bao2 {
public static void main(String[] args) {
System.out.println(Student.getClassRoom()); //通过类名访问,必须为静态方法
}
public static class Student{
//必须有static,否则无法与下面的变量与方法统一
private static String ClassRoom="classroom1";
//必须有static,否则报错:
//无法从静态上下文中引用非静态 变量 ClassRoom
public static String getClassRoom(){
//必须有static才能通过类名访问,否则报错:
// 无法从静态上下文中引用非静态 方法 getClassRoom()
return ClassRoom;
//只有静态成员变量才能return
}
}
}
（3）静态成员变量初始化
静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。
1.就地初始化
在定义时直接给出初始值
public static class Student{
private String name;
private static String classRoom = "Bit306";
}
2.静态代码块初始化
八，代码块
1.什么是代码块
使用 { } 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块
（1）普通代码块
定义在方法中的代码块
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}//这种用法较少见
（2）构造代码块（实例代码块）
构造块：定义在类中的代码块(不加修饰符)，构造代码块一般用于初始化实例成员变量。
public static class Student{
//实例成员变量
private String name;
private int age;
public Student() {
System.out.println("I am good!");
}
//实例代码块
//这里可以少写一行
{
this.name = "bit";
this.age = 12;
System.out.println("I am better !");
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public static void main(String[] args) {
Student stu = new Student();//不用在"bit",12这样的赋值了
stu.show();
}
输出
I am better ! I am good! name: bit age: 12
主观：就是比含参构造方法少了一行，且定义对象不需要在写局部变量了
（3）静态代码块
使用static定义的代码块称为静态代码块。
一般用于初始化静态成员变量。
public static class Student {
private String name;
private static String classRoom;
//实例代码块 直接赋值
{
this.name = "bit";
System.out.println("I am 实例");
}
// 静态代码块 直接赋值
static {
classRoom = "bit306";
System.out.println("I am 静态");
}
//无参构造方法
public Student() {
System.out.println("I am 构造");
}
public void show(){
System.out.println(name+" ,"+classRoom);
}
}
public static void main(String[] args) {
Student s1 = new Student();
s1.show();
}
}
输出
I am 静态 I am 实例 I am 构造 bit ,bit306【注意】
1.静态代码块不管生成多少个对象，其只会执行一次
2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并
4.实例代码块只有在创建对象时才会执行
九，内部类
1.什么是内部类
1.在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。
2.目的：一个部分只为另一个部分服务时，使用内部类，这也是封装的一种体现。
public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类
2.内部类的分类
根据内部类定义的位置不同，一般可以分为以下几种形式：
1. 成员内部类(普通内部类：static未修饰或 static未修饰的 成员内部类)
2. 局部内部类(不谈修饰符)、匿名内部类
public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类
public class InnerClass1{
}
// 成员位置定义：被static修饰 ---> 静态内部类
static class InnerClass2{
}
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
class InnerClass5{
}
}
（1）实例内部类（static未修饰）
public static class OutClass {
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 实例内部类：未被static修饰
class InnerClass{
int c;
public void methodInner(){
// 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
//外部类已经int过a,b,定义过A，B方法
a = 100;
b =200;
methodA();
methodB();
// 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
c = 300;
System.out.println(c);
// 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
OutClass.this.c = 400;
System.out.println(OutClass.this.c);
}
}
public static void main(String[] args) {
// 外部类：对象创建 以及 成员访问
OutClass outClass = new OutClass();
System.out.println(outClass.a);
System.out.println(OutClass.b);
System.out.println(outClass.c);
outClass.methodA();
outClass.methodB();
System.out.println("=============实例内部类的访问=============");
// 要访问实例内部类中成员，必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodInner();
}
}
【注意】
1. 实例内部直接调用外部
2. 受public、private等访问限定符的约束
3. 同名时，实例内部优先访问自己，如果要访问外部类同名的成员，必须：外部类名
称.this.同名成员 来访问
4. 实例内部想创建对象必须外部先创建
5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部想访问实例内部中的成员，必须先创建外部类的对象
（2）静态内部类（static修饰）
public class OutClass {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 静态内部类：被static修饰的成员内部类
static class InnerClass{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
// a = 100; // 编译失败，因为a不是类成员变量
b =200;
// methodA(); // 编译失败，因为methodB()不是类成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.methodInner();
}
}
细心的小伙伴可能会发现，怎么这里的类，都加了static呢？因为它们都是static内部类
【注意】
1. 在静态内部类中只能访问外部类中的静态成员
2. 创建静态内部类对象时，不需要先创建外部类对象
（3）局部内部类（了解）
public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}
【注意】
1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class
4. 几乎不会使用
（4）匿名内部类
与接口有关，以后来填坑
十，对象的打印
重写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;
}
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]
