Day03:
new 的功能：
当使用 new 时会 1，创建给定类的实例对象；2，为它分配内存；3，调用给定类定义的一个构造函数。
构造函数： 是用于创建和初始化类实例的方法。构造函数初始化新对象及其变量。每个类在没有手动添加构造函数时，java都会默认有一个空的构造函数。
内存管理：
当创建新的对象时，java会自动分配适当数量的内存，当对象使用完后，会指向一个null值，表示不再使用，（该对象中没有任何正在使用的或者被存储数组中的变量），java定期查询未被使用的对象，并收回这些对象占有的内存。（无用单位收集）
实例变量和类变量由两部分组成，句点左边是对象和类的引用，句点右边为变量。
类变量：是在类中定义和存储。适用于类及其所有实例对象。
类变量的修改会直接影响所有实例中的这个变量。
定义类变量的方法：在前面加上关键字 static 。
类变量用 ：类.（句点）类变量
实例变量用 ：实例对象.（句点）实例变量
这样便于调试。
格式输出方法：
System.out.format();
相当于 C语言中 printf();
%,d 格式化整数
%,f 格式化浮点数 %,11f 控制位数
%n 换行
有返回值的方法也可以赋给变量
a.b().c()；
a对象有个b方法，b方法的返回值是一个对象，该对象中有一个c方法，可以通过这个嵌套方法调用c方法。
lei.bl.fangf();
fangf() 方法是在实例变量 bl 储存的对象中定义，这个实例变量本身在对象 lei 中。
class test01{
public static void main(String[]args){
a lei = new a();
lei.bl.fangf();
}
}
class a{
b bl = new b();
}
class b{
void fangf(){
System.out.println("hhhhhh");
}
}
关于 System.out.println(); 的详解：
println() 方法是在实例变量 out 储存的对象中定义，这个实例变量本身在对象 System 中。
out 是一个 PrintStream 类型实例变量 。
System 中有一个 public static final PrintStream out 实例变量
out 是一个 PrintStream 类型实例变量。
PrintStream 类中有一个 println() 方法。
类方法：
类方法作用于整个类，而且不需要实例化，可以直接使用。
堆栈内存数据问题：
java 的基础类型存放在 stack（栈）上，new 出对象后，只把 对象 的 reference（引用）存放在 stack（栈）中用来指向某个对象，对象本身放在 heap（堆）中。
还有，调用方法时传递的参数以及在调用中创建的临时变量都保存在 stack（栈）中，速度较快。
其它变量，如（static）静态变量（类变量），实例变量等都在堆中创建，速度较慢。
java 中引用可以看做是一种不需要操作且受限制的指针，引用无大小，不可计算，安全，强转要小心。
对象的引用：引用是一个地址，它指明了对象的变量和方法储存的位置。
强制类型转换：
1.基础类型之间的转换
2.类型实例对象之间的转换
3.基础类型转和对象之间的转换
大转小必须强制类型转换，小转大不需要强制类型转换。
位数多的基础类型转成位数小的基础类型需要强制转换
父类转子类需要强制转换
class a{
}
class b extends a{
}
class test{
public static void main(String[]args){
a a1 = new a();
b b1 = new b();
a1 = b1; //子类转父类
a a2 = new a();
b b2 = new b();
b2 = (b)a2; // 父类转子类 需要强制类型转换
a a3 = new b(); // 子类 new 一个父类对象
b b3 = (b)new a(); // 父类 new 一个子类对象 需要强制类型转换
}
}
基础类型和对象之间的转换
class test{
public static void main(String[]args){
Integer a = new Integer(7801); // Integer 对象转成 int 基础类型
int i = a.intValue();
System.out.println(i);
String str = "6500"; //String 对象转成 int 基础类型
int w = Integer.parseInt(str);
System.out.println(w);
}
}
多态：
必须满足三个要求：1.必须有继承；2.必须有重写；3.必须有父类引用指向子类对象
多态例子代码：
public class testdt {
public static void main(String[]args){
BaiDog bd = new BaiDog(); //new 一个子类对象
HeiDog hd = new HeiDog(); //new 一个子类对象
ZhuRen zr = new ZhuRen("bai",bd); //将子类对象传入父类引用中（父类引用指向子类对象）
ZhuRen zz = new ZhuRen("hei",hd); //将子类对象传入父类引用中（父类引用指向子类对象）
zr.wan(); //调用的是被重写后的方法
zz.wan(); //调用的是被重写后的方法
}
}
class Dog { //父类 Dog
public void jiao(){ //父类 jiao( )方法
System.out.println("wang,wang。。。。");
}
}
class BaiDog extends Dog { //继承 Dog 父类的 BaiDog 子类
public void jiao(){ //重写父类的 jiao( )方法
System.out.println("baidog-jiao111,baidog-jiao111......");
}
}
class HeiDog extends Dog { //继承 Dog 父类的 HeiDog 子类
public void jiao(){ //重写父类的 jiao( )方法
System.out.println("heidog-jiao222,heidog-jiao222......");
}
}
class ZhuRen {
String name;
Dog d;
ZhuRen(String name,Dog d){ //需要传入一个父类 Dog对象
this.name=name;
this.d=d;
}
public void wan(){
d.jiao(); //调用传入对象的jiao( )方法，必须是父类中有的方法，子类重写后会显示重写后的内容，子类没有重写显示的是父类这个方法中的内容
}
}
执行结果：baidog-jiao111,baidog-jiao111......
heidog-jiao222,heidog-jiao222...... //显示的是子类重写后的方法内容
基础类型对应的对象:
boolean Boolean
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
对象封装器
自动封装和拆封：一种自动转换过程，处理表示同一类值的基本类型和对象时更容易。
自动封装：就是自动的将基本类型转换为对象；自动拆封则是相反。
如果编写语句时，本来应该出现基本类型变量的地方使用了对象（或者相反），相应的值会自动被转换，以便能够成功执行。
两个对象之间的比较：
== 比较的是两个对象的地址，检查是否是同一个对象
equals()是 Object 类的方法 两个对象引用相同则返回true(与==用法一样)，如果子类重写equals( )方法用法请参考重写后的equals( )方法
把相同内容赋给多个 String，返回的还是同一个对象。
判断对象所在的类：
对象.getClass().getName();
获得对象所在类的类名。
getClass() 和 getName() 都是Object 类中定义的方法
判断对象是否是这个类的对象：
用 instanceof 判断，左边是对象引用，右边是类名
boolean pd = (b)对象 instanceof (a)类型；(b对象是否是一个a类型对象，返回boolean类型)
