🌠作者：@TheMythWS.
🎇座右铭：不走心的努力都是在敷衍自己，让自己所做的选择，熠熠发光。
目录
🌈面向过程和面向对象的区别🌟
面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，以函数为最小单位，考虑怎么做。
面向对象：注重找“参与者”,将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
案例：
人把大象装进冰箱：
面向过程：
函数1：打开冰箱(){人站在冰箱前，打开冰箱，冰箱卡到30度角的时候，冰箱的灯打开了.........}
函数2：储存大象(){大象先迈左腿，再迈右退，考虑冰箱能不能装下......}
函数3：关闭冰箱(){人站在冰箱前，关闭冰箱，冰箱开到30度角的时候，冰箱的灯关闭了..........}面向对象：
人{
打开(冰箱){
冰箱.打开();
}存储(大象){
大象.进入();
}
关闭(冰箱){
冰箱.关闭();
}
}
冰箱{打开（）{ 1.2.3.}
关闭（）{}
}
柜子{
}
大象{
进入(冰箱){}
}
面向过程 ---> 面向对象 , 其实就是由执行者 ---> 指挥者的 一个过渡
面向过程：编年体
面向对象：纪传体二者相辅相成,并不是对立的。解决复杂问题,通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统;具体到微观操作,仍然使用面向过程方式来处理
🌈类和对象的关系🌟
【1】万事万物皆对象
【2】
对象：具体的事物，具体的实体，具体的实例，模板下具体的产品
类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板【3】一般在写代码的时候先写类，然后在根据类创建对应的对象。
🌈面向对象的三个阶段🌟
面向对象三个阶段：
【1】面向对象分析OOA -- Object Oriented Analysis
对象：张三，王五，朱六，你，我
抽取出一个类----》人类类里面有什么：
动词--》动态特性--》方法
名词--》静态特性--》属性
【2】面向对象设计OOD -- Object Oriented Design
先有类，再有对象：
类：人类： Person
对象：zhangsan ，lisi，zhuliu
【3】面向对象编程OOP -- Object Oriented Programming
🌈创建类🌟
创建类：
（1）属性（field 成员变量）
属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
属性定义格式：
[修饰符] 属性类型 属性名 = [默认值] ;
（2）方法
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法定义格式：
[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}
void代表没有返回值；方法的作用：重用代码，封装功能，便于修改
注意：类名采用大驼峰定义，下面我们开始定义一个Person类，我们都知道人有姓名有年龄等，这些都是他的属性（成员变量），人可以吃饭，睡觉等这些是他的行为（方法）。
说明：在这先不介绍public、static等修饰符，要等后面学习权限修饰符等等知识再做具体介绍。
一般来说一个java文件只写一个类，此处写到一起是为了大家能够直观观看。
一个java文件只能有一个public的类
public class Person {
//名词---》属性---》成员变量---》放在类中方法外（注意：我们只把有需要的内容写到代码里，不相关的东西不要放在代码中）
int age ;//年龄
String name;//姓名
double height;//身高
double weight;//体重
//动词---》方法
//吃饭
public void eat(){
int num = 10;//局部变量：放在方法中
System.out.println("我喜欢吃饭");
}
//睡觉：
public void sleep(String address){
System.out.println("我在"+address+"睡觉");
}
//自我介绍：
public String introduce(){
return "我的名字是："+name+"，我的年龄是："+age+",我的身高是："+height+",我的体重是："+weight;
}
}🌈创建对象🌟
什么是实例化？
定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自 带的内置类型，而类是用户自定义了一个新的类型， 用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象，这个过程也称创建对象。
注意事项：
- new 关键字用于创建一个对象的实例.
- 使用 . 来访问对象中的属性和方法.
- 同一个类可以创建多个实例.
用测试类演示创建对象
public class Test {//测试类
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建一个人类的具体的对象/实例：
//创建一个对象，对象的名字叫：zs
//Person 属于 引用数据类型
//第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
Person zs = new Person();
zs.name = "张三";
zs.age = 19;
zs.height = 180.4;
zs.weight = 170.4;
//再创建一个对象：
//再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次
Person ls = new Person();
ls.name = "李四";
ls.age = 18;
ls.height = 170.6;
ls.weight = 160.5;
//对属性值进行读取：
System.out.println(zs.name);
System.out.println(ls.age);
//对方法进行操作：
//不同的对象，属性有自己的特有的值，但是方法都是调用类中通用的方法。
//属性：各个对象的属性是独立的，
//方法：各个对象的方法是共享的。
zs.eat();
ls.eat();
zs.sleep("教室");
/*String str = zs.introduce();
System.out.println(str);*/
System.out.println(zs.introduce());
}
} 
❗❗❗ 【注意事项 】
1️⃣当一个引用赋值为 null 的时候，代表：这个引用不指向任何对象！
2️⃣引用能不能指向引用？？？ 不能，但是引用能够指向另一个引用指向的对象。
public static void main(String[] args) { Person person1 = new Person(); Person person2 = new Person(); person1 = person2;此时代表 person1这个引用指向了person2这个引用指向的对象
3️⃣一个引用能不能同时指向多个对象？？ ？ 不能
public static void main(String[] args) { Person person1 = new Person(); person1 = new Person(); person1 = new Person(); person1 = new Person(); person1 = new Person(); person1 = new Person(); }最后person1只是指向了一个对象，就是最后一个对象。
类和对象的说明
1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
2. 类是一种自定义的类型，可以用来定义变量.
3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量.
4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东 西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间.
🌈局部变量和成员变量的区别🌟
区别1：代码中位置不同
成员变量：类中方法外定义的变量
局部变量：方法中定义的变量 代码块中定义的变量
区别2：代码的作用范围
成员变量：当前类的很多方法
局部变量：当前一个方法（当前代码块）区别3：是否有默认值
成员变量：有
局部变量：没有
引用数据类型： null
区别4：是否要初始化
成员变量：不需要，不建议初始化，后续使用的时候再赋值即可
局部变量：一定需要，不然直接使用的时候报错区别5：内存中位置不同
成员变量：堆内存
局部变量：栈内存
区别6：作用时间不同
成员变量：当前对象从创建到销毁
局部变量：当前方法从开始执行到执行完毕
public class Student {
byte e;
short s;
int c ;//成员变量：在类中方法外
long num2;
float f ;
double d;
char ch;
boolean bo;
String name;
public void study(){
int num = 10 ; //局部变量：在方法中
System.out.println(num);//10
//int num ;重复命名，出错了
{
int a;//局部变量：在代码块中
}
int a;
if(1==3){
int b;
}
System.out.println(c);
}
public void eat(){
System.out.println(c);
}
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.c);
System.out.println(s.bo);
System.out.println(s.ch);
System.out.println(s.d);
System.out.println(s.e);
System.out.println(s.f);
System.out.println(s.name);
System.out.println(s.num2);
System.out.println(s.s);
s.d = 10.4;
}
}运行结果：
🌈构造器🌟
我们直接从下面代码入手：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建一个Person类的具体的对象/实例/实体：
/*
创建对象的过程：
1.第一次遇到Person的时候，进行类的加载（只加载一次）
2.创建对象，为这个对象在堆中开辟空间
3.为对象进行属性的初始化动作
new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
可以自己显式 的将构造器编写出来：
构造器的格式：
[修饰符] 构造器的名字(){
}
构造器和方法的区别：
1.没有方法的返回值类型
2.方法体内部不能有return语句
3.构造器的名字很特殊，必须跟类名一样
构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。
调用构造器的目的是给属性进行赋值操作的。
注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。
实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写
*/
Person p = new Person();
System.out.println(p.age);
System.out.println(p.name);
System.out.println(p.height);
Person p2 = new Person();
System.out.println(p2.age);
System.out.println(p2.name);
System.out.println(p2.height);
}
}🌈构造器的重载🌟
首先定义Person类：
public class Person {
//属性：
String name;
int age;
double height;
//空构造器
public Person(){
}
public Person(String name,int age,double height){
//当形参名字和属性名字重名的时候，会出现就近原则：
//在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
this.name = name;
this.age = age;
this.height = height;
}
public Person(String a,int b){
name = a;
age = b;
}
//方法：
public void eat(){
System.out.println("我喜欢吃饭");
}
}测试类：
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
/*
1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
2.一般我们会重载构造器，在重载的构造器中进行属性赋值操作
3.在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。
4. 当形参名字和属性名字重名的时候，会出现就近原则：
在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
*/
Person p = new Person();
/*p.age = 19;
p.name = "lili";
p.height = 180.4;*/
Person p2 = new Person("lili",19,180.4);
System.out.println(p2.age);
System.out.println(p2.height);
System.out.println(p2.name);
}
}🌈内存分析🌟
从下面代码进行分析：
代码1：
public class Person {
int id;
int age;
public static void main(String args[]){
Person p1= new Person();
}
} 
代码2：
public class Person {
int id;
int age;
String school;
public Person (int a,int b,String c){
id=a;
age=b;
school=c;
}
public static void main(String args[]){
Person p= new Person(1,20, "海淀");
}
} 
代码3：
class Person{
int id;
int age;
String school;
Person (int a,int b,String c){
id=a;
age=b;
school=c;
}
public void setAge(int a){
age=a;
}
}
public class Test {
public static void main(String[] args) {
Test t=new Test();
int age=40;
Person tom=new Person(1,20,"海淀");
Person jack=new Person(2,30,"朝阳");
t.change1(age);
t.change2(tom);
t.change3(jack);
System.out.println(age); //40
System.out.println("id:"+jack.id+",age:"+jack.age+",school:"+jack.school); //id:2,age:66,school:"朝阳"
}
public void change1(int i){
i=3366;
}
public void change2(Person p){
p=new Person(3,22,"西城");
}
public void change3(Person p){
p.setAge(66);
}
} 
注：之后省略了person构造器的画图
System.out.println(age);
age为main栈帧中的变量，age--->40
System.out.println("id:"+jack.id+",age:"+jack.age+",school:"+jack.school);
在jack对象中去找自身的属性值---> 2 66 朝阳
🌈this🌟
回顾创建对象的过程：
（1）在第一次遇到一个类的时候，对这个类要进行加载，只加载一次。
（2）创建对象，在堆中开辟空间
（3）对对象进行初始化操作，属性赋值都是默认的初始值。
（4）new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值
通过对代码的调试，可以发现：
从上面的效果能够看到：this指代的就是当前对象：
内存：（省略了部分过程）
比较完善的过程
第一步：
第二步：
this关键字 用法：
（1）this可以修饰属性：
总结：当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰如果不发生重名问题的话，实际上你要是访问属性也可以省略this.
public class Person { //属性 int age; String name; double height; //空构造器 public Person(){ } //有参构造器 public Person(int age,String name,double height){ this.age = age; this.name = name; this.height = height; } //方法： public void eat(){ int age = 10; System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age System.out.println(this.age);//这里的this指代当前调用eat方法的对象->P,所以这里的age指代的就是属性中的age System.out.println("我喜欢吃饭"); } }（2）this修饰方法：
总结：在同一个类中，方法可以互相调用，this.可以省略不写。public class Person { //属性 int age; String name; double height; //空构造器 public Person(){ } //有参构造器 public Person(int age,String name,double height){ this.age = age; this.name = name; this.height = height; } //方法： /*public void eat(){ int age = 10; System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age System.out.println(this.age);//这里指代的就是属性的age System.out.println("我喜欢吃饭"); }*/ public void play(){ /*this.*/eat();//对象p先调用play方法，再调用eat方法 System.out.println("上网"); System.out.println("洗澡"); } public void eat(){ System.out.println(/*this.*/age);//因为当前age没有重名，所以调用的是属性中的age，this可以省略不写 System.out.println("吃饭"); } }（3）this可以修饰构造器：
总结：同一个类中的构造器可以相互用this调用，
注意：this修饰构造器必须放在第一行，只能放在构造器内部使用public class Person { //属性 int age; String name; double height; //空构造器 public Person(){ } //有参构造器 public Person(int age,String name,double height){ this(age,name);//调用当前类中带两个参数的构造器 this.height = height; } public Person(int age,String name){ this(age);//调用当前类中带一个参数的构造器 this.name = name; } public Person(int age){ this.age = age; } //方法： /*public void eat(){ int age = 10; System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age System.out.println(this.age);//这里指代的就是属性的age System.out.println("我喜欢吃饭"); }*/ public void play(){ /*this.*/eat(); System.out.println("上网"); System.out.println("洗澡"); } public void eat(){ System.out.println(/*this.*/age); System.out.println("吃饭"); } }图解：
🌈static🌟
【1】static可以修饰：属性，方法，代码块，内部类。
【2】static修饰属性；
public class Test { //属性： int id; static int sid; //这是一个main方法，是程序的入口： public static void main(String[] args) { //创建一个Test类的具体的对象 Test t1 = new Test(); t1.id = 10; t1.sid = 10; Test t2 = new Test(); t2.id = 20; t2.sid = 20; Test t3 = new Test(); t3.id = 30; t3.sid = 30; //读取属性的值： System.out.println(t1.id); System.out.println(t2.id); System.out.println(t3.id); System.out.println(t1.sid); System.out.println(t2.sid); System.out.println(t3.sid); } }内存分析：
一般官方的推荐访问方式：可以通过类名.属性名的方式去访问：
static修饰属性总结：
（1）在类加载的时候一起加载入方法区中的静态域中
（2）先于对象存在
（3）访问方式： 对象名.属性名 类名.属性名（推荐）static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 --》这个情况下，就可以用static修饰的属性
public class TheMythStudent { //属性： String name; int age; static String school; //这是一个main方法，是程序的入口： public static void main(String[] args) { TheMythStudent.school = "TheMyth"; //创建学生对象： TheMythStudent s1 = new TheMythStudent(); s1.name = "张三"; s1.age = 19; //s1.school = "TheMyth"; TheMythStudent s2 = new TheMythStudent(); s2.name = "李四"; s2.age = 21; //s2.school = "TheMyth"; System.out.println(s2.school); } }属性：
静态属性 （类变量）
非静态属性（实例变量）【3】static修饰方法；
public class Demo { int id; static int sid; public void a(){ System.out.println(id); System.out.println(sid); System.out.println("------a"); } //1.static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行 static public void b(){// //System.out.println(this.id);//4.在静态方法中不能使用this关键字 //a();//3.在静态方法中不能访问非静态的方法 //System.out.println(id);//2.在静态方法中不能访问非静态的属性 System.out.println(sid);//即使没对象，也能访问sid，因为sid先于对象创建 System.out.println("------b"); } //这是一个main方法，是程序的入口： public static void main(String[] args) { //5.非静态的方法可以用对象名.方法名去调用 Demo d = new Demo(); d.a(); //6.静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐） Demo.b();//推荐！！！ d.b(); //在同一个类中可以直接调用 b(); } }在静态方法中不能访问非静态的属性的原因：
静态方法b先于对象存在，如果去访问非静态属性id（id属于对象特有的），就会出现报错，对象还没被创建，因此访问id的时候，系统不能识别对于a方法，一定是能够去访问id和sid的，因为要调用a方法，只有对象才能去调用a方法，有了对象当然能访问到id和sid
练习(村民饮水问题)：
class Village {//村庄类 // 类变量:对象共享 static int waterAmount;// 模拟水井的水量 // 实例变量:成员变量 int peopleNumber;// 村庄的人数 String name;// 村庄的名字 // 初始化name这个成员变量 public Village(String name) { this.name = name; } // 类定义成员变量方法里使用静态变量 // 静态(实例)成员方法只能使用静态变量,不能使用非静态变量 /** * 1.内存加载顺序：类变量 类方法 实例变量 实例方法 2.类方法不能访问实例变量，只能访问类变量 3.实例方法可以访问类变量和实例变量 4.类变量共享 * * @return */ public static int getWaterAmount() { return waterAmount; } public static void setWaterAmount(int waterAmount) { if (waterAmount > 0) { Village.waterAmount = waterAmount; } } // 村庄饮水量 void drinkWater(int waterCount) { if (waterCount >= 0) { Village.waterAmount = waterAmount - waterCount; System.out.println(name + "喝了" + waterCount + "升水");// name加不加this都可以 } else { waterAmount = 0; } } public static int lookWaterAmount() { return waterAmount; } public int getPeopleNumber() { return peopleNumber; } public void setPeopleNumber(int peopleNumber) { this.peopleNumber = peopleNumber; } } public class Land {//测试类 public static void main(String[] args) { // 设置井水容量 Village.setWaterAmount(200); int leftWater = Village.waterAmount;// 静态变量用类名.来访问 System.out.println("水井中共存有" + leftWater + "升水"); Village zhangjiazhuang = new Village("张家庄"); String name1 = zhangjiazhuang.name; zhangjiazhuang.setPeopleNumber(100); Village wangjiazhuang = new Village("王家庄"); String name2 = wangjiazhuang.name; wangjiazhuang.setPeopleNumber(80); System.out.println(name1 + "的人数：" + zhangjiazhuang.getPeopleNumber()); System.out.println(name2 + "的人数：" + wangjiazhuang.getPeopleNumber()); wangjiazhuang.drinkWater(70); leftWater = Village.lookWaterAmount(); System.out.println(name1 + "发现井中有" + leftWater + "升水"); zhangjiazhuang.drinkWater(50); System.out.println("水井中的水还有" + Village.waterAmount + "升水"); System.out.println("水井中的水还有" + Village.getWaterAmount() + "升水"); System.out.println("水井中的水还有" + Village.lookWaterAmount() + "升水"); } }
🌈代码块🌟
【1】类的组成：属性，方法，构造器，代码块，内部类
【2】代码块分类：普通块，构造块，静态块，同步块（多线程）
【3】代码：public class Test { //属性 int a; static int sa; //方法 public void a(){ System.out.println("-----a"); { //普通块限制了局部变量的作用范围 System.out.println("这是普通块"); System.out.println("----000000"); int num = 10; System.out.println(num); } //System.out.println(num); //if(){} //while(){} } public static void b(){ System.out.println("------b"); } //构造块 { System.out.println("------这是构造块"); } //静态块 static{ System.out.println("-----这是静态块"); //在静态块中只能访问：静态属性，静态方法 System.out.println(sa); b(); } //构造器 public Test(){ System.out.println("这是空构造器"); } public Test(int a){ this.a = a; } //这是一个main方法，是程序的入口： public static void main(String[] args) { Test t = new Test(); t.a(); Test t2 = new Test(); t2.a(); } }
代码块大致执行顺序：
1.最先执行静态块，只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂，数据库的初始化信息都放入静态块。
一般用于执行一些全局性的初始化操作。2.再执行构造块，（不常用）
3.再执行构造器，
4.再执行方法中的普通块。👀注意：如果是在继承关系中
1.优先执行父类的静态变量
2.再执行父类的静态块
3.再执行子类的静态变量
4.再执行子类的静态块
需要注意的是，静态代码块和静态变量初始化只会在类第一次被加载到JVM时执行一次。
5.再执行父类的成员变量（实例变量）
6.再执行父类的构造块
7.再执行父类的构造器
8.再执行父类的普通块(若有调用)
9.其次再执行子类的成员变量（实例变量）
10.再执行子类的构造块
11.再执行子类的构造器
12.再执行子类的普通块(若有调用)。
class Animal { public String name = "动物"; public int age; A a = new A(); static { System.out.println("Animal static{}"); } { System.out.println("Animal {}"); } public Animal() { System.out.println("Animal()"); } public void eat() { { System.out.println("父类的普通块"); } } } class Dog extends Animal { A a = new A(); static { System.out.println("Dog static{}"); } { System.out.println("Dog {}"); } public Dog() { //super();//编译器会帮你默认加上的 System.out.println("Dog()"); } @Override public void eat() { { System.out.println("子类重写后父类方法后的普通块"); } } } class A{ static { System.out.println("A static{}"); } public A(){ System.out.println("A()"); } public void eat(){ { System.out.println("A的普通块"); } } } public class Test { public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); System.out.println("====="); Animal animal = new Animal(); animal.eat(); } }
🌈包，import 🌟
【1】生活案例：
邮寄快递：中国.四川.成都市.****小区.6号楼.3单元.404房.themyth
历史：常山赵子龙【2】包的作用：
为了解决重名问题（实际上包对应的就是盘符上的目录）
解决权限问题【3】创建包：
包名定义：
（1）名字全部小写
（2）中间用.隔开
（3）一般都是公司域名倒着写 ： com.jd com.msb com.bite com.ithema
（4）加上模块名字：
com.jd.login com.jd.register
（5）不能使用系统中的关键字：nul,con,com1---com9.....
（6）包声明的位置一般都在非注释性代码的第一行：【4】导包问题：
//声明包： package com.themyth2; import com.themyth1.Person; //导包：就是为了进行定位 import java.util.Date; public class Test { //这是一个main方法，是程序的入口： public static void main(String[] args) { new Person(); new Date(); new java.sql.Date(1000L);//在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。 new Demo(); } }总结：
（1）使用不同包下的类要需要导包： import **.*.*; 例如：import java.util.Date;
（2）在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
（3）同一个包下的类想使用不需要导包，可以直接使用。
（4）在java.lang包下的类，可以直接使用无需导包：
（5）IDEA中导包快捷键：alt+enter
可以自己设置自动导包（6）可以直接导入*：
虽然是代表了所有，但是不是把里面的都导进来，随用随去。
用到哪个类，它就会导入哪个类。
（7）包语句最多只有一条
【5】在Java中的导包没有包含和被包含的关系：
设置目录平级的格式（不是包含和被包含的显示）：
【6】静态导入：
//静态导入： import static java.lang.Math.*; //导入：java.lang下的Math类中的所有静态的内容 public class Test { //这是一个main方法，是程序的入口： public static void main(String[] args) { System.out.println(random()); System.out.println(PI); System.out.println(round(5.6)); } //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。 public static int round(double a){ return 1000; } }
1732
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
