|
????????几类关键字及零碎小知识小节
几类关键字：
一、package关键字的使用
??????? 1.为了更好地实现项目那种类的管理，提供包的管理
??????? 2.使用package声明类或接口所属的包，声明在源文件的首行
??????? 3.包属于标识符，遵循标识符的命名规则、规范（xxxtttzzz）、“见名知意”
??????? 4.每“.”一次，就代表一层目录文件
??????? 5.同一个包下不能命名同名的接口、类；不同的包下可以命名同名的接口，类
二、import（导入）关键字的使用
导包：指出需要使用的类在什么位置。
格式：import 包名称.类名称；
例子：import day4.Student;
????????1.在源文件中显式的使用import结构导入指定包下的类、接口
??????? 2.声明在包的声明和类之间
??????? 3.若需要导入多个结构，则并列写即可
??????? 4.可以使用“xx.*”的方式，表示可以导入xx包下的所有结构，但是若使用xx子包下的结构则仍然需要显式导入
??????? 5.若使用的类或接口是java.long包下的，则可以省略import结构
??????? 6.若使用的类或接口是本包下定义的则可以省略import结构
??????? 7.若在源文件中使用了不同包下的同名类，则必须至少有一个类需要以全类名（包名.类名）的方式显示,对于和当前类属于同一个包的情况，可以省略导包语句。
??????? 8.import static：导入指定类或接口中的静态结构:属性；方法
?????
三、this关键字的使用
??????? 1.this可以用于修饰、调用：属性、方法、构造器
??????? 2.this修饰属性和方法:
??????????? this理解为:当前对象 或 当前正在创建的对象
??????????? 在类的方法中可以使用“this.属性”或“this.方法”的方式，调用当前对象的属性或方法。但在通常情况下会选择省略“this.”。在特殊情况下若方法的形参和类的属性同名时必须显式地使用“this.变量”的方式，表名此变量是属性，而非形参。在类的构造器中可以使用“this.属性”或“this.方法”的方式，调用当前正在创建的对象的属性或方法。但在通常情况下会选择省略“this.”在特殊情况下若构造器的形参和类的属性同名时必须显式地使用“this.变量”的方式，表名此变量是属性，而非形参。
??????? 3.this调用构造器
??????????? 在类的构造器中可以显示地使用“this(形参列表）"方式，调用本类中指定的其他构造器
??????????? 构造器中不能通过“this(形参列表）"方式调用自己
??????????? 若一个类中有n个构造器，则最多有n-1个构造器中使用了“this(形参列表）"，但此过程中对象始终只有一个
??????????? 规定：“this(形参列表）"必须声明在当前构造器中的首行
??????????? 构造器内部最多只能声明一个“this(形参列表）"用于调用其他本类中的构造器
tip1：如果想要本类当中成员变量要使用格式：this.成员变量名
tip2："通过谁调用的方法，谁就是this."
?
??? ?
四、super关键字的使用
??? 1.super理解为：父类的(和this类似）
??? 2.super可以用来调用：属性、方法、构造器
??? 3.super的使用:调用属性和方法
??????? 3.1可以在子类的方法或者构造器中通过使用“super.属性”或者“super.方法”的方式显示的调用父类中声明的属性或方法。但是通常情况下习惯省略“super.”
??????? 3.2特殊情况：当子类和父类定义了同名的结构时，要想在子类中调用父类声明的结构时，则必须显式地使用“super.属性”或者“super.方法”的方式表明调用的是父类中声明的结构。
???? 4.super调用构造器：
??????? 4.1可以在子类的构造器中显式地使用“super（形参列表）”的方式，调用父类中声明的指定的构造器
??????? 4.2“super（形参列表）”的使用，必须声明在子类构造器的首行
??????? 4.3在类的构造器中，针对于“this（形参列表）或者“super（形参列表）”只能二选一，不能同时出现
??????? 4.4在构造器的首行，没有显式地声明“this（形参列表）”或者则默认调用的是父类中空参的构造器：super()
??????? 4.5在类的多个构造器中，至少有一个类的构造器中使用了“super（形参列表）”，调用父类中的构造器
this和super关键字使用小节：
??????? tip1：在类中若以this修饰，则this先会在本类中找被修饰的结构，若本类中不存在，则找本类继承的父类中找被this修饰的结构，而super则是直接找父类中在本类被super修饰的结构。
??????? tip2：一个类的构造器可能有多个，构造器的首行不是“this”就是“super”只能是这两个中的一个，不可能有其他情况。即一个类中有n个构造器，最多有n-1个使用this，剩下一个用super。
??????? tip3：无论通过那个构造器创建子类对象，需要保证先初始化父类，目的是当子类继承父类后，“继承”父类中所有的属性和方法，因此子类有必要知道父类如何为对象进行初始化，因此优先加载父类。所以“super（形参列表）”或“this（形参列表）”调用语句只能作为构造器中的第一句出现。
??????? tip4.super关键字用于访问父类内容，而this用于访问本类内容，用法也有三种：
1.在本类的成员方法中，访问本类的成员变量
2.在本类的成员方法中，访问本类中另外一个成员方法
3.在本类的构造方法中，访问本类的另外一个构造方法，
其中this（...）的调用也必须是构造方法的第一个语句，唯一一个
?tip5.super和this两种构造不能同时使用
五、private 关键字的使用：
总述：
??????? 针对类来说，private是对类中的成员变量进行封装。在java中，只有创建了对象才能使用这个类（类似于C语言中的结构体）。然而在创建好的对象或者类中，设计者并不希望类的或者创建好的对象中的某一成员变量参数是非法的，好比：设计者A创建了一个类是人类，而另外一个设计者B在使用这个类创建一个名字叫“张三”的对象时，处于不知道是什么奇葩想法将张三这个对象的年龄设置成了-100岁，这对于设计者A来说是最不愿意看到的，因为这是不合法的（一个人类-100岁？音阙诗听！）。为了防止这种情况发生，所以出现了private关键字对相应的成员变量，比如人这个类中的年龄这个成员变量进行保护（修饰、限定）既然提及private关键字对成员变量做出保护，那么private是这怎么实现对成员变量的保护？其实它是这么实现的：当成员变量A被private关键字修饰以后，在创建好相应对象后，对成员变量A进行赋值时，要调用setA()这个方法（若A的类型是boolean时则调用isA()这个方法），才能对成员变量A进行赋值，然而在setA()方法的方法体中就可以对成员变量A的赋值做出限制（自己可以在方法体中写想写的限制），比如若A是年龄，则可以限制A不能小于0；再如A是纸张页数，则可以限制A不能小于0等等。但此方法没有返回值，这就产生一个问题，如何访问已经设置好（传递好参数）的成员变量A呢？在此可以调用getA()方法，此方法则用于对成员变量A的返回。（补充：当方法的局部变量和方法的成员变量重名时，由“就近原则”，优先使用局部变量。如果要使用本类当中的成员变量，则可以使用this关键字，格式为：this.成员变量名）简而言之：定义年龄数字时可能出现年龄数据不匹配问题，用private关键字将需要保护的成员变量进修饰。
注意：
???????? 一旦使用private进行修饰，则本类中仍然可以随意访问，但超出本类范围之外则不能直接访问（直接访问指:对象.)
???????? 间接访问private成员变量即定义一对Getter/Setter方法；
???????? 名称setXxx并且set有参数，参数类型和private成员变量类型一致；无返回值
???????? 名称getXxx并且get无参数，返回值就是private成员变量；返回值类型和成员变量对应
???????? 对于基本类型boolean值，Getter方法一定写isXxx形式，而setXxx不变
六、instanceof:关键字的使用：
??????? a instanceof A；判断对象a是否是类A的实例。如果是返回true，如果不是返回false
格式：对象 instanceof 类名称
将会得到一个boolean值结果，即判定前面对象能不能当做后面类型的实例
??????? 要求a所属的类与类A必须是子父类的关系，否则编译错误（不要忽略Object类）
??????? 使用场景：为了避免在向下转型是出现ClassCastException的异常在向下转型之前先进行instanceof的判断，一旦返回true就进行向下转型，若返回false则终止向下转型
??????? 若a instanceof A返回true且a instanceof B也返回true，那么类B是类A的父类。
七、final:最终的：
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写
??? 1.final可以用来修饰的结构：类、方法、变量（局部/成员）
以方法为列其格式：修饰符 final 返回值类型 方法名称（参数列表）{方法体}
以类为列：
格式：public final class 类名称{//...}
含义：当前这个类不能有任何子类（太监类）
注：一个类若是final类，则其中所有方法都无法进行覆盖重写（因为没有儿子）
??? 2.final修饰类表示此类没有子类，即此类不能被其他类所继承
比如{
String类(因为其底层是char类型数组，String已经把此数组的所有操作写完，无需扩充)
System类（因为其操作已经写完，无需扩充）
StringBuffer类
}
??? 3.final修饰方法：此方法不可以被重写
比如：Object类中getClass();
??? 4.final修饰变量：此时的“变量'就成为一个常量
??????? 4.1final修饰属性：可以考虑赋值的位置有：显式初始化（针对值相同的情况）、代码块初始化（调了一个能跑异常的方法）、构造器中初始化（针对值不同的情况）{不用get方法是因为，在调用构造器后，所有成员变量已经初始化地存在，此时被final的成员变量就永远为默认初始化，后面在调用get方法也不能将其值进行修改，那么这个成员变量就是一个多余的成员变量}
??????? 4.2final修饰变量：尤其是用final来修饰形参时，表名此形参是一个常量。当调用此方法时，给常量形参赋值一个实参，一旦赋值以后就只能在方法内使用此形参，但不能重新赋值
??? static final：用于修饰属性则代表此属性为全局常量；用于修饰方法则表示此方法能用类来调用且不能被重写
对于成员变量来说，如果使用final关键字修饰，这此变量照样不可以改变
????????A.由于成员变量有默认值，使用final后要手动赋值，不会再给默认值
????????B.对于final的成员变量，要么直接赋值，要么通过构造方法赋值，二选一
????????C.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值
tip1：对于类，方法来说，abstract关键字和final关键字不能同时使用，因为矛盾
tip2：不能使用一个final类来来作为父类
八、static关键字的使用（随着类的加载而加载）：
??????? 1.static：静态的
??????? 2.static可以用于修饰：属性、方法、代码块、内部类
??????? 3.static修饰属性:静态变量（类变量）
??????????? 3.1 属性，按是否使用static修，又分为：静态属性 VS 非静态属性（实例变量）
??????????????? 实例变量：当创建了类的多个对象，每个对象都独立拥有一套类中的非静态属性。当修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。
??????????????? 静态变量：当创建了类的多个对象，多个对象共享一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过的。即若一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享一份数据。
??????????? 3.2static修饰属性的其他说明：
??????????????? 1.静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
??????????????? 2.静态变量的加载要早于对象。
??????????????? 3.由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中
??????????????? 4.??????????????? 类变量????????????? 实例变量
??????????????? 类???????????????? yes???????????????? no
??????????????? 对象?????????????? yes???????????????? yes
??????????? 3.3静态属性举例和实例理解：System.out;Math.PI；
同班同学
学生类： |学生对象：
|
姓名，年龄，学号 |姓名：张三，年龄12，学号1
所在班级：1班 |所在班级:1班
教室数据只在类中保存唯一一份数据
则所有本类对象同享一份数据 |学生对象：
|
|姓名：王五，年龄14，学号2
|所在班级：1班
|学生对象：
|
|姓名：小红，年龄13，学号3
|所在班级：1班
对于姓名，年龄，学号，每个对象都有自己独立的数据
对于所在教室，应该是多个对象共用一份数据
一旦用了static，那么这样的内容不再属于自己，而是属于类的，所以凡是本类的对象，都共享同一份
????????4.static修饰方法：静态方法
??????????? 4.1随着类的加载而加载，可以通过“类.静态方法”的方式进行调用
??????????? 4.2?????????????? 静态方法????????????? 非静态方法（实例方法）
????????????? 类???????????????? yes???????????????? no
????????????? 对象?????????????? yes???????????????? yes
??????????? 4.3静态方法中只能调用静态的方法或属性；非静态方法中既可以调用非静态的方法也可以调用静态方法
??????????? 4.4一旦static修饰成员方法，那么被修饰的成员方法就成为了静态方法，静态方法不属于对象，属于类。
??????????? 4.5若没有static，那么必须首先创建对象，然后通过对象才能使用成员方法；若有了static，则不需要创建对象，直接就能通过类名称来使用成员方法
??????? 5.static注意点：
??????????? 5.1在静态的方法内部不能使用this关键字、super关键字
??????????? 5.2关于静态方法和静态属性，从生命周期角度去理解
??????????? 5.3构造器不能声明static
??????? 6.在开发中，如何确定一个属性是否要声明为static？
??????????????? > 属性是可以被多个对象所共享的，不会随对象的不同而不同
??????????????? >类中的常量分页常常声明为static
????????? 在开发中，如何确定一个方法是否要声明为static？
??????????????? >操作静态属性的方法，通常设置为static的
??????????????? >工具类中的方法习惯上声明为静态方法，如Math、Arrays、Collections
static程序分析{
首先类加载进内存
class Chinese{
String name;
int age;
在没有创造对象前实例变量name和age是并没有实际分配存储空间
static String nation;
当类加载时后，在方法区静态域内String nation已经存在，并且初始值为null
}
public class test{
public static void main(String[] args) {
Chinese.nation="中国";
将方法区静态域内String nation值从null赋值为"中国"
Chinese c1 = new Chinese();
在栈内存声明变量c1指向堆内存中存放Chinese()对象的存储空间，
在此存储空间中有存储实例变量的name和age存储空间，
并且将name初始化为null和age初始化为0；
c1.name="张三";
c1.age=19;
将name的值从null改变为"张三"，将age的值从0改变为19
c1.nation="CHN";
通过c1指向的对象调用nation，将nation的值从"中国"改为"CHN"
Chinese c2 = new Chinese();
在栈内存声明变量c2指向堆内存中新存放Chinese()对象的存储空间，
在此存储空间中有存储实例变量的name和age存储空间，
并且将name初始化为null和age初始化为0；
c2.name="王五";
c2.age=29;
将name的值从null改变为"王五"，将age的值从0改变为29
c2.nation="CHINA";
通过c1指向的对象调用nation，将nation的值从"CHN"改为"CHINA"
System.out.println(c1.nation);
输出 通过c1指向的对象调用nation，nation中的值
}
}
}
tip1：无论是成员变量还是成员方法，若有static都推荐使用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法（）
tip2：静态不能直接访问非静态。因为内存中先有静态内容后有非静态内容；静态中不用this。因为this代表当前对象，通过谁调用的方法，谁就是当前对象
tip3：用类名称访问静态成员变量的时候，全程和对象没有关系，只和类有关系
九、abstract关键字的使用
??????? 1.abstract：抽象的
??????? 2.abstract可以修饰的结构：类、方法
??????? 3.abstract修饰类：抽象类
??????????? >此类不能实例化
??????????? >抽象类中一定有构造器，便于子类实例化的时候调用（涉及子类对象实例化全过程
??????????? >开发中都会提供抽象类的子类，让子类对象实例化，完成相关的操作-->抽象的前提：继承性
??????? 4.abstract修饰方法：抽象方法
??????????? >抽象方法只有方法的声明，没有方法体
??????????? >包含程序方法的类，一定是个抽象类。反之抽象类中可以没有抽象方法
??????????? >若子类重写了父类中的所有抽象方法后，此子类方可实例化；
???????????? 若子类没有重写父类中的所有抽象方法后，意味着此子类也是抽象类，需要abstract修饰
???? abstract使用上的注意点：
??????? 1.abstract不能用于修饰：属性，构造器，私有方法，静态方法（静态方法不能被重写），final的方法，final的类
零散小知识：
一、顶级父类----java.lang.Object类：
基本概念：
????? 1.Object是所有java类层次结构的根类（父类/根父类）.每个类都使用Object作为超类（根类，父类），所有对象（包括数组）都实现这个类的方法
????? 2.若在类的声明中未使用extends关键字知名其父类，则默认父类为java.lang.Object类
????? 3.Object类那种的功能（属性，方法）就具有通用性:
??????????? 属性：无
??????????? 方法：equals()/toString()/getClass()获取当前对象的所属类/hashCode()/clone()/wait()/notify()/notifyAll()/finalize()和垃圾回收有关，一般不主动调用----{ final、finally、finalize区别，其中finalize是方法名字，当对象在被回收之前，对象会调用finalize方法（如果该方法让一个新的引用变量重新引用该对象，则会重新激活对象，使得垃圾无法回收）}
????? 4.Object类只声明了一个空参构造器
????? 5.若没有显式的声明一个类的父类则此类继承于java.lang.Object类
????? 6.所有java类（除java.lang.Object类）均直接或者间接继承于java.lang.Object类，意味着，所有java类都具有java.lang.Object类声明的方法。
????? 7.数组是一个特殊的类，继承了Object类。数组是一个特殊的类，继承了Object类，数组也作为Object类的子类出现，可以调用Object类中声明的方法
二、javabean（ 标准类）是一种java用于写成的可重用组件。所谓javabean是指符合如下标准的java类（在本人看来类似一个C语言中的结构体）：
??????? 类是公共的； 所有成员变量（有属性）均使用private保护，并且为每一个成员变量（属性）添加对应的get，set方法；有一个无参的公共构造器；存在一个有参构造。
三、简述UML图（类图）：包含了包名，类名，属性，方法的描述
??????? 其中+表示public类型，-表示private类型，#表示protected类型；
??????? 属性的写法{属性名：属性类型}
??????? 方法的写法{方法类型（+、-）方法名（参数名：参数类型）：返回值类型}
/*
简单的对象内存分析，其中Customer类和Account均为标准的JavaBean
*/
public class CustomerTest {
public static void main(String[] args) {
Customer p1 = new Customer("jane","Smith");
在栈内存声明了p1变量，
在堆内存创建了一个Customer对象（对象中的三个属性初始化均为null），
堆内存中的对象Customer将首地址赋值给了栈中声明的变量P1，
同时将堆内存中的对象Customer的属性中的firstName和lastName分别
赋值"jane"和"Smith"，而最后一个属性account依然是初始化值null
Account acct = new Account(1000, 2000, 0.0123);
在栈内存中声明了变量acct，在堆内存创建了一个Account对象
（对象中的三个属性初始化均为null），堆内存中的对象Account将
首地址赋值给了栈中声明的变量acct，同时将堆内存中的对象Account
的属性分别赋值10009,2000,0.0123
p1.setAccount(acct);
将栈内存中变量acct存储的地址值赋值给了堆内存中名
为p1的Customer对象中的属性account，使得account也和acct
一样指向堆内存中名为acct的Account对象
p1.getAccount().deposit(100);
p1.getAccount().withdraw(960);
p1.getAccount().withdraw(2000);
System.out.println(
"顾客【"+p1.getLastNamne()+
","+p1.getFirstName()+"】有一个账户：id是"+
p1.getAccount().getId()+
",利率是"+p1.getAccount().getAnnualInterestRate()*100+
"%，存款是"+p1.getAccount().getBalance()
);
}
}
四、MVC设计模式：
??????? 将整个程序分为三层：视图模型层；控制器层；数据模型层
??????? 模型层（model 主要用于处理数据）：
??????????????????? 数据对象封装{model.bean/domain}；
??????????????????? 数据库操作类{model.dao}；
??????????????????? 数据库{model.db}
??????? 视图层（view 显示数据）：
??????????????????? 相关工具类{view.utils}；
??????????????????? 自定义view{view.ui}
??????? 控制层（controller 处理业务逻辑）：
??????????????????? 应用界面相关{controller.activity}存放fragment{controller.fragment}
??????????????????? 显示列表的适配器{controller.adapter}访问相关的{controller.service}
??????????????????? 抽取的基类{controller.base}
五、属性赋值的先后顺序的总结：
??????? A.默认初始化值
??????? B. 显式初始化
??????? C. 构造器中初始化
??????? D. 通过“对象.方法”或“对象.属性”的方式（可以反复使用）
??? 以上操作的先后顺序：A-B-C-D（最终赋值从D到A看），其中A-C只执行一次，D可以反复执行
六、 java中的JUnit单元测试（此操作针对eclipse）
??? A.选中当前工程-右键选择：build path - add library - JUnit4 - 下一步
??? B.创建java类，进行单元测试：此时的java类要求：
??????????? 1）此类是公共的
??????????? 2）此类要提供公共的无参的构造器
??? C.此类中声明单元测试方法:此时的单元测试方法：方法的权限是public，没有返回值类型，没有形参
??? D.此单元测试方法上需要声明注解：@Test,并在单元测试类当中，导入import org.junit.Test;
??? E.声明好单元测试方法以后，就可以在方法体内测试相关代码
??? F.写完代码后，左键双击单元测试方法名称，右键：run as - JUnit Test
?
?七、==和equals的区别：
??? A、==的使用：
??????? ==是运算符
??????? 1.可以使用在基本数据类型变量和引用数据类型变量中
??????? 2.若比较的是基本数据变量：比较两个保存的数据是否相等（不一定类型要相同）。即基本类型是进行数值大小比较；
????????? 若比较的是引用类型数据变量：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体。即应用类型是进行地址值比较；
??????? 补充：==使用使用时，必须保证符号左右两边的变量类型一致
??? B、equals()方法的使用：
??????? 1.是一个方法而非运算符
??????? 2.只能使用于引用数据类型
??????? 3.Object类中equals()的定义
equals方法的一个源码：
public boolean equals(Object obj) {
return (this == obj);
}
参数：Object obj：可以传递任意的对象，==比较运算符，返回一个布尔值 true false
基本数据类型：比较的是值。应用数据类型：比较两对象地址值
其中this指哪个对象调用的方法，方法中的this就是哪个对象；
p1调用的equals方法，所以this就是p1
obj指传递的参数p2
this==obj-->p1==p2
说明：Object类中equals()的定义和==的作用是相同的：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体
public boolean equals(Objet obj);
a.equals(b); <=> b.equals(a);
其中Objet接收任何对象，当参数是一个字符串并且内容相同才不给true.
常用：常量.equals(变量) (如果常变量位置相反，容易引起空指针异常)
?????????4.像String、data、File、包装类等都重写了Object类中equals()方法，重写以后比较的不是两个引用的地址值是否相等，而是比较两个对象的“实体内容”是否相等。
??????? 5.通常情况下自定义的类如果使用equals(),也通常是比较两个对象的的“实体内容”是否相等。那么需要对Object类中equals()进行重写.重写原则：比较两个实体对象内容是否相同
??????? 5.在回答引用类调用equals()方法的出结果时先弄清楚这个equals是否进行了重写。
??????? 6.x.equals(null)返回是一个false，若null.equals则曝出空指针异常，因此在对象调用equals前先判断对象是否为null
??????? 7.重写equals方法：Object类的equals方法，默认比较的是两个对象的地址值，没有意义。所以重写equals方法：
public boolean equals(Object obj) {
if(this==obj){return true;}
if(obj instanceof 当前类){
当前类 u=(当前类)obj;
return this.属性1==obj.属性1&&
this.字符串类型属性2.equals(obj.字符串类型属性2)&&
...；
}
return false;
}
八、Object类中的toString()使用
??? 1.当输出一个对象的引用时，实际上就是调用当前对象的toString()
??? 2.Object类中toString()的定义：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
??? 3.像String、Data、File、包装类等都重写了Object中的toString()方法，使得在调用对象的toString()方法时，返回“实体内容”信息
??? 4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的“实体内容”
??? 5.直接打印对象的地址值没有意义，需要重写object中的toString方法
九、包装类的由来：
??????? 基本数据类型和Object类是两个独立个部分，这对于面向对象类型的java而言是不完整的，因此需要给基本数据类型赋予类的特性，以此完善java面向对象的特性。解决基本数据类型拥有类的特性的方式就是包装类。即将基本类型转换为引用类当可泛型使用。基本数据类型使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本数据装起来,而这个类叫包装类，可以使用类中方法来操作这些基本类型的数据
装箱：把基本类型的数据，包装到包装类中（基本类型数据-->包装类）
构造方法：
Integer（int value）：构造一个新分配的Integer对象，它表示指定的int值
Integer(String s)：构造一个新分配的Integer对象，它表示String参数所指示的int值
传递的字符串，必须是基本类型的字符串，否则会抛出异常“100”正确，"a"抛出异常
静态方法：
static Integer valueOf（int i）返回一个表示指定的int值的Integer实例
static Integer valueOf（String s）返回保存指定的String值的Integer对象
拆箱：在包装类中取出基本类型的数据（包装类-->基本类型数据）
成员方法：
int intValue()以int类型返回Integer的值
基本类型与字符串类型之间的相互转换：
基本类型->字符串（String）
1.基本类型的值+""最简单的方法（工作中常用）
2.包装类的静态方法toString(参数),不是Object类的toString（）重载
static String toString(int i)返回一个表示指定整数的String对象
3.String类的静态方法valueOf（参数）
static String valueOf(int i)返回int参数的字符串表示形式
字符串（String）->基本类型
使用包装类的静态方法parseXXX（“字符串”）
Integer类:static int parseInt(String s)
Double类：static double parseDouble(String s)
??? 包装类的使用提示：
??????? 1.java提供了8中基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
??????? 2.这8种包装类的转换6种都是首字母大小写转换，而int-->Integer;char-->Character
基本类型的包装类：
int（基本类型） -> Integer（包装类）
char（基本类型） -> Character（包装类）
其他基本类型，将其首字母大写即其对应的包装类
基本类型 -（装箱）> 包装类
包装类 -（拆箱）> 基本类型
在jdk1.5开始支持自动装箱、自动拆箱。
??????? 3.掌握：基本数据类型、包装类、String三者之间的相互转换
??????? 4.包装类是个类，初始默认值为null;包装类是一个类不能进行加减乘除运算
??????? 5.在Integer内部定义了一个IntegerCache结构，IntegerCache中定义了Integer[],保存了-128到+127范围的整数，如果使用自动装 箱的方式给Integer赋值的范围在-128到+127范围时课堂直接使用数组中的元素，不用再去new。目的：提高效率
??????? 6.String类型-->基本数据类型、包装类：调用包装类中的parseXxx(String s)；可能会报NumberFormatException异常boolean向怎么赋值怎么赋值
??????? 7.基本数据类型、包装类-->String类型:调用String重载的valueOf(Xxx xxx)；连接运算（+“”）；调用String重载的valueOf(Xxx xxx)
??????? 8.java 5新特性：自动装箱与自动拆箱，基本类型数据和包装类之间可以自动相互转换
??????? 9.包装类-->基本数据类型:调用包装类的xxxValue()
??????? 10.基本数据类型转换为对应包装类：调用包装类的构造器
十、main()方法的使用
??? 1.main()方法作为程序的入口
??? 2.main()方法也是一个普通的静态方法
??? 3.main()方法可以作为编程人员与控制台的交互方式。（之前：使用Scanner），可以天然地给main传递参数
??? 如何将控制台获取到的数据传给形参：String[] args?
运行时：java 类名 "Tom" "jerry" "123" "true"
sout(args[0]);//"Tom"
sout(args[3]);//"true" --> Boolean.parseBoolean(args[3]);
小节：
??? public static void main(String[] args) {//方法体}
??? 权限修饰符：private、缺省、protected、public -->封装性
??? 修饰符：static\final\abstract\native可以用于修饰方法
??? 返回值类型：无返回值/有返回值-->return
??? 方法名：标识符命名规则规范
??? 形参列表：重载 VS 重写：参数的值传递机制；体现对象的多态性
??? 方法体：体现方法功能
十一、关于增强for循环：
增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写（这是JDK1.5以后的特性）
Collection<E>extend Iterable<E>所有的单列集合都可以使用增强for
public interface Iterable<T>实现这个借口允许对象成为“foreach”语句的目标
增强for循环：用于遍历集合和数组
格式：
for（集/数组的数据类型 变量名：集合名/数组名）{
sout（变量名）；
}
十二、tips
tip1：编译器默认int ... arr等价于int[] arr
tip2：调用方法时，优先调用确定参数个数的方法
tip3：在三元运算符中，问号后面的两个结构的数据结果必须统一成一个类型
tip4：基本数据类型变量不是类
tip5：在常量池中，若两个变量的内容相同，那么就表示这两个引用变量会指向常量池中同一个数据
tip6：只要用到比较，当数据类型为基本数据类型，则用==；若数据类型为引用数据类型，则用equals
tip7：能强制类型转换的一定有子父类关系（不要忽略Object类）
tip8：在类中使用向下转型就是为了使用子类中特有的属性
tip9：由于生命周期的原因，静态里面不能调非静态
tip10：常用api（应用程序编程接口-好多类好多方法）：键盘输入，随机数，ArrayList
JAVA语言学习小节：ArrayList集合、引用类型和字符串的片面理解
ArrayLIst集合：
ArrayList集合就是的顺序表，它可以实现对其所含元素的增、删、取得、返回其长度（所含元素个数）的操作，然而其长度是可变的（这得益于它可以增加元素）。
ArrayList集合的直接打印的是集合中的内容而非地址，然而ArrayList集合保存的却是元素的地址。因此这也决定了，向ArrayList集合传递的数据类型只能是泛型（<E>）,而泛型只能是引用类型数据，不能是基类型数据，因为基本类型数据无地址值。若非要向ArrayList集合传递基本类型数据，那么可以选择向ArrayList集合传递基本类型的包装类。
字符串：
??????? 字符串内容不可变，因此字符串可以共享；其效果上相当于char[]字符数组，但底层原理为byte[]字节数组
?????? 1. 字符串构造方法:
public String() ==>应用类型
public String(char[] array) ==>字符数组
public String(byte[] array) ==>字节数组
?????? 2. 字符常量池：
程序中直接写上双引号的字符，这些字符在字符串常量池中，而new的字符串不在字符常量池中。????? ?
??????? 3.String中相关常用方法：
public int length();得到字符串长度
public String concat(String str);拼接字符串
public char charAt(int index);得到字符串的单个字符，下标从0开始
public int indexOf(String str);找参数字符串在本字符串中首次出现的索引位置，无返回-1
punlic String substring(int index);截取从参数一直到末尾
punlic String substring(int begin,int end); [开始，结尾）
public char[] toCharArray(int index);字符串-->字符数组
public byte[] getByte();得到当前字符串底层的字节数组
punlic String replace(CharSeqence oldString,CharSeqence newString);
punlic String[] split(String regex);按参数规则，将字符串切分为若干部分；对“.”切就用“\\.”切
分割线=============================================
小思考：
?1. java语言中创建类、对象的理解：
???? 类的创建：类包含什么静态特征、什么动态特征。即类等于属性加方法，在java语言中，类的方法定义不能用static，个人理解就是不能将类中方法写死。
??? ?
???? 对象创建：类名 对象名=new 类名();
???? 这个新的对象是什么类的，有什么静态特征，有什么动态特征。
??? ?
?2. 对逻辑的刻画：
???? 对逻辑的刻画不仅仅局限于任何一门编程语言或是任何一门计算机语言。在此讨论的是更为广泛的对逻辑的刻画：逻辑=计算+选择
|