要点：
我们只关心栈与堆这两种内存空间
实例变量是声明在类中方法之外的地方
局部变量声明在方法或方法的参数上
对象引用变量与primitive主数据类型变量都是在栈上
不管是实例变量或局部变量，对象本身都会在堆上
如果实例变量全都是primitive主数据类型的，则Java会一句primitive主数据类型的大小为该实例变量留下空间。
如果有声明变量但没有给它赋值，则只会留下变量的空间；
private Antenna ant；
直到引用变量被赋值一个新的Antenna对象才会在堆上占有空间：
private Antenna ant = new Antenna（）；
唯一能够调用构造函数的办法就是新建一个类。（严格说起来，这是唯一在构造函数之外能够调用构造函数的方式）
构造函数没有写，编辑器会默认给你写一个无参的构造函数；
Duck myDuck = new Duck();
public Duck(){ 1.方法有返回类型，构造函数没有返回类型。2.一定要与类的名称相同
}
构造函数的一项关键特征是它会在对象能够被赋值给引用之前就执行。
public class Duck{
public Duck(){
System.out.println("Quack");
}
}
public class UseDuck{
public static void main(String[] args){
Duck d = new Duck(); 这样会启动Duck的构造函数
}
}
}
public class Duck{
int size;
public Duck(){
System.out.println("Quack");
}
public void setSize(int newSize){
size = newSize;
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck();
d.setSize(42); 问题出在这里，Duck在此处已经建立。但是却没有size值！你必须依赖Duck的用户记得要设定大小
}
}
如果某种对象不应该在状态被初始化之前就使用，就别让任何人能够在没有初始化的情况下取得该种对象！最好的方法是在初始化的程序代码放在构造函数中，然后把构造函数设定成需要参数的。
public class Duck{
int size;
public Duck(int duckSize){
System.out.println("Quack");
size = duckSize；
System.out.println("size is " + size);
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck(42);
}
}
编译器只会在你完全没有设定构造函数时才会调用，如果你写了一个有参数的构造函数，如果需要一个没有参数的构造函数，就必须自己动手写。
要点：
@实例变量保存在所属的对象中，位于堆上。
@如果实例变量是个对对象的引用，则引用与对象都是在堆上
@构造函数是个会在新建对象的时候执行程序代码
@构造函数必须与类同名且没有返回类型
@你可以用构造函数来初始被创建对象的状态
@如果你没有写构造函数，编译器会帮你安排一个
@磨人的构造函数没有参数
@如果你写了构造函数，则编译器就不会调用
@最好能有无参数的构造函数让人可以选择使用默认值
@重载的构造函数意思是又超过一个以上的构造函数
@重载的构造函数必须有不同的参数
@两个构造函数的参数必须是不同的
@实例变量有默认值，原始的默认值是0/0.0/false，引用的默认值是null
调用父类构造方法是用super（）；
如果我们没有调用super（）会发生什么？
编译器会帮我们加上super（）的调用。
所以编译器有两种涉入构造函数的方式：
1如果你没有编写构造函数
public ClassName(){
super();
}
2.如果你有构造函数但是没有调用super();
编译器帮忙假的一定回事没有参数的版本，假设弗雷有多个重载版本，也只有无参数的这个版本会被调用到。
父类的部分必须在子类创建完成之前就必须完整的成型。
对super()的调用必须是构造函数的第一个语句
public Boop(int i){
size = i;
super(); 错！ super（）调用必须是第一个语句!!
}
public Boop(){ 这样都行
}
public Boop(int i){
size = i；
}
使用this()来从某个构造函数调用同一个类的另外一个构造函数。换句话说this 就是个对对象本身的引用。
this() 只能被用在构造函数中，且必须是第一行语句。
super()与this()不能兼得.
每个构造函数可以调用super()或this()，但是不能同时调用
class Mini extends Car{
Color color;
public Mini(){
this(Color.red); 无参数的构造函数以默认的颜色调用真正的构造函数
}
public Mini(Color c){
super("Mini"); 这才是真正的构造函数
color = c;
}
public Mini (int size){
this(Color.red); 有问题！！不能同时调用super()和this()，两者只有一个会是第一行语句
super(size);
}
}
"变量的声明周期如何影响对象的声明周期？"
如果对象的唯一引用死了，对象就会从堆中被踢开。
有3种方法可以释放对象的引用：
1.引用永久性的离开它的范围。
void go(){
life z = new Life();
}
2.引用被赋值到其他的对象上。
Life z = new Life();
z= new Life();
3.直接将引用设定为null
Life z = new Life();
z = null;
+
要点：
我们只关心栈与堆这两种内存空间
实例变量是声明在类中方法之外的地方
局部变量声明在方法或方法的参数上
对象引用变量与primitive主数据类型变量都是在栈上
不管是实例变量或局部变量，对象本身都会在堆上
如果实例变量全都是primitive主数据类型的，则Java会一句primitive主数据类型的大小为该实例变量留下空间。
如果有声明变量但没有给它赋值，则只会留下变量的空间；
private Antenna ant；
直到引用变量被赋值一个新的Antenna对象才会在堆上占有空间：
private Antenna ant = new Antenna（）；
唯一能够调用构造函数的办法就是新建一个类。（严格说起来，这是唯一在构造函数之外能够调用构造函数的方式）
构造函数没有写，编辑器会默认给你写一个无参的构造函数；
Duck myDuck = new Duck();
public Duck(){ 1.方法有返回类型，构造函数没有返回类型。2.一定要与类的名称相同
}
构造函数的一项关键特征是它会在对象能够被赋值给引用之前就执行。
public class Duck{
public Duck(){
System.out.println("Quack");
}
}
public class UseDuck{
public static void main(String[] args){
Duck d = new Duck(); 这样会启动Duck的构造函数
}
}
}
public class Duck{
int size;
public Duck(){
System.out.println("Quack");
}
public void setSize(int newSize){
size = newSize;
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck();
d.setSize(42); 问题出在这里，Duck在此处已经建立。但是却没有size值！你必须依赖Duck的用户记得要设定大小
}
}
如果某种对象不应该在状态被初始化之前就使用，就别让任何人能够在没有初始化的情况下取得该种对象！最好的方法是在初始化的程序代码放在构造函数中，然后把构造函数设定成需要参数的。
public class Duck{
int size;
public Duck(int duckSize){
System.out.println("Quack");
size = duckSize；
System.out.println("size is " + size);
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck(42);
}
}
编译器只会在你完全没有设定构造函数时才会调用，如果你写了一个有参数的构造函数，如果需要一个没有参数的构造函数，就必须自己动手写。
要点：
@实例变量保存在所属的对象中，位于堆上。
@如果实例变量是个对对象的引用，则引用与对象都是在堆上
@构造函数是个会在新建对象的时候执行程序代码
@构造函数必须与类同名且没有返回类型
@你可以用构造函数来初始被创建对象的状态
@如果你没有写构造函数，编译器会帮你安排一个
@磨人的构造函数没有参数
@如果你写了构造函数，则编译器就不会调用
@最好能有无参数的构造函数让人可以选择使用默认值
@重载的构造函数意思是又超过一个以上的构造函数
@重载的构造函数必须有不同的参数
@两个构造函数的参数必须是不同的
@实例变量有默认值，原始的默认值是0/0.0/false，引用的默认值是null
调用父类构造方法是用super（）；
如果我们没有调用super（）会发生什么？
编译器会帮我们加上super（）的调用。
所以编译器有两种涉入构造函数的方式：
1如果你没有编写构造函数
public ClassName(){
super();
}
2.如果你有构造函数但是没有调用super();
编译器帮忙假的一定回事没有参数的版本，假设弗雷有多个重载版本，也只有无参数的这个版本会被调用到。
父类的部分必须在子类创建完成之前就必须完整的成型。
对super()的调用必须是构造函数的第一个语句
public Boop(int i){
size = i;
super(); 错！ super（）调用必须是第一个语句!!
}
public Boop(){ 这样都行
}
public Boop(int i){
size = i；
}
使用this()来从某个构造函数调用同一个类的另外一个构造函数。换句话说this 就是个对对象本身的引用。
this() 只能被用在构造函数中，且必须是第一行语句。
super()与this()不能兼得.
每个构造函数可以调用super()或this()，但是不能同时调用
class Mini extends Car{
Color color;
public Mini(){
this(Color.red); 无参数的构造函数以默认的颜色调用真正的构造函数
}
public Mini(Color c){
super("Mini"); 这才是真正的构造函数
color = c;
}
public Mini (int size){
this(Color.red); 有问题！！不能同时调用super()和this()，两者只有一个会是第一行语句
super(size);
}
}
"变量的声明周期如何影响对象的声明周期？"
如果对象的唯一引用死了，对象就会从堆中被踢开。
有3种方法可以释放对象的引用：
1.引用永久性的离开它的范围。
void go(){
life z = new Life();
}
2.引用被赋值到其他的对象上。
Life z = new Life();
z= new Life();
3.直接将引用设定为null
Life z = new Life();
z = null;
我们只关心栈与堆这两种内存空间
实例变量是声明在类中方法之外的地方
局部变量声明在方法或方法的参数上
对象引用变量与primitive主数据类型变量都是在栈上
不管是实例变量或局部变量，对象本身都会在堆上
如果实例变量全都是primitive主数据类型的，则Java会一句primitive主数据类型的大小为该实例变量留下空间。
如果有声明变量但没有给它赋值，则只会留下变量的空间；
private Antenna ant；
直到引用变量被赋值一个新的Antenna对象才会在堆上占有空间：
private Antenna ant = new Antenna（）；
唯一能够调用构造函数的办法就是新建一个类。（严格说起来，这是唯一在构造函数之外能够调用构造函数的方式）
构造函数没有写，编辑器会默认给你写一个无参的构造函数；
Duck myDuck = new Duck();
public Duck(){ 1.方法有返回类型，构造函数没有返回类型。2.一定要与类的名称相同
}
构造函数的一项关键特征是它会在对象能够被赋值给引用之前就执行。
public class Duck{
public Duck(){
System.out.println("Quack");
}
}
public class UseDuck{
public static void main(String[] args){
Duck d = new Duck(); 这样会启动Duck的构造函数
}
}
}
public class Duck{
int size;
public Duck(){
System.out.println("Quack");
}
public void setSize(int newSize){
size = newSize;
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck();
d.setSize(42); 问题出在这里，Duck在此处已经建立。但是却没有size值！你必须依赖Duck的用户记得要设定大小
}
}
如果某种对象不应该在状态被初始化之前就使用，就别让任何人能够在没有初始化的情况下取得该种对象！最好的方法是在初始化的程序代码放在构造函数中，然后把构造函数设定成需要参数的。
public class Duck{
int size;
public Duck(int duckSize){
System.out.println("Quack");
size = duckSize；
System.out.println("size is " + size);
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck(42);
}
}
编译器只会在你完全没有设定构造函数时才会调用，如果你写了一个有参数的构造函数，如果需要一个没有参数的构造函数，就必须自己动手写。
要点：
@实例变量保存在所属的对象中，位于堆上。
@如果实例变量是个对对象的引用，则引用与对象都是在堆上
@构造函数是个会在新建对象的时候执行程序代码
@构造函数必须与类同名且没有返回类型
@你可以用构造函数来初始被创建对象的状态
@如果你没有写构造函数，编译器会帮你安排一个
@磨人的构造函数没有参数
@如果你写了构造函数，则编译器就不会调用
@最好能有无参数的构造函数让人可以选择使用默认值
@重载的构造函数意思是又超过一个以上的构造函数
@重载的构造函数必须有不同的参数
@两个构造函数的参数必须是不同的
@实例变量有默认值，原始的默认值是0/0.0/false，引用的默认值是null
调用父类构造方法是用super（）；
如果我们没有调用super（）会发生什么？
编译器会帮我们加上super（）的调用。
所以编译器有两种涉入构造函数的方式：
1如果你没有编写构造函数
public ClassName(){
super();
}
2.如果你有构造函数但是没有调用super();
编译器帮忙假的一定回事没有参数的版本，假设弗雷有多个重载版本，也只有无参数的这个版本会被调用到。
父类的部分必须在子类创建完成之前就必须完整的成型。
对super()的调用必须是构造函数的第一个语句
public Boop(int i){
size = i;
super(); 错！ super（）调用必须是第一个语句!!
}
public Boop(){ 这样都行
}
public Boop(int i){
size = i；
}
使用this()来从某个构造函数调用同一个类的另外一个构造函数。换句话说this 就是个对对象本身的引用。
this() 只能被用在构造函数中，且必须是第一行语句。
super()与this()不能兼得.
每个构造函数可以调用super()或this()，但是不能同时调用
class Mini extends Car{
Color color;
public Mini(){
this(Color.red); 无参数的构造函数以默认的颜色调用真正的构造函数
}
public Mini(Color c){
super("Mini"); 这才是真正的构造函数
color = c;
}
public Mini (int size){
this(Color.red); 有问题！！不能同时调用super()和this()，两者只有一个会是第一行语句
super(size);
}
}
"变量的声明周期如何影响对象的声明周期？"
如果对象的唯一引用死了，对象就会从堆中被踢开。
有3种方法可以释放对象的引用：
1.引用永久性的离开它的范围。
void go(){
life z = new Life();
}
2.引用被赋值到其他的对象上。
Life z = new Life();
z= new Life();
3.直接将引用设定为null
Life z = new Life();
z = null;
+
要点：
我们只关心栈与堆这两种内存空间
实例变量是声明在类中方法之外的地方
局部变量声明在方法或方法的参数上
对象引用变量与primitive主数据类型变量都是在栈上
不管是实例变量或局部变量，对象本身都会在堆上
如果实例变量全都是primitive主数据类型的，则Java会一句primitive主数据类型的大小为该实例变量留下空间。
如果有声明变量但没有给它赋值，则只会留下变量的空间；
private Antenna ant；
直到引用变量被赋值一个新的Antenna对象才会在堆上占有空间：
private Antenna ant = new Antenna（）；
唯一能够调用构造函数的办法就是新建一个类。（严格说起来，这是唯一在构造函数之外能够调用构造函数的方式）
构造函数没有写，编辑器会默认给你写一个无参的构造函数；
Duck myDuck = new Duck();
public Duck(){ 1.方法有返回类型，构造函数没有返回类型。2.一定要与类的名称相同
}
构造函数的一项关键特征是它会在对象能够被赋值给引用之前就执行。
public class Duck{
public Duck(){
System.out.println("Quack");
}
}
public class UseDuck{
public static void main(String[] args){
Duck d = new Duck(); 这样会启动Duck的构造函数
}
}
}
public class Duck{
int size;
public Duck(){
System.out.println("Quack");
}
public void setSize(int newSize){
size = newSize;
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck();
d.setSize(42); 问题出在这里，Duck在此处已经建立。但是却没有size值！你必须依赖Duck的用户记得要设定大小
}
}
如果某种对象不应该在状态被初始化之前就使用，就别让任何人能够在没有初始化的情况下取得该种对象！最好的方法是在初始化的程序代码放在构造函数中，然后把构造函数设定成需要参数的。
public class Duck{
int size;
public Duck(int duckSize){
System.out.println("Quack");
size = duckSize；
System.out.println("size is " + size);
}
}
public class UseADuck{
public static void main (String[] args){
Duck = new Duck(42);
}
}
编译器只会在你完全没有设定构造函数时才会调用，如果你写了一个有参数的构造函数，如果需要一个没有参数的构造函数，就必须自己动手写。
要点：
@实例变量保存在所属的对象中，位于堆上。
@如果实例变量是个对对象的引用，则引用与对象都是在堆上
@构造函数是个会在新建对象的时候执行程序代码
@构造函数必须与类同名且没有返回类型
@你可以用构造函数来初始被创建对象的状态
@如果你没有写构造函数，编译器会帮你安排一个
@磨人的构造函数没有参数
@如果你写了构造函数，则编译器就不会调用
@最好能有无参数的构造函数让人可以选择使用默认值
@重载的构造函数意思是又超过一个以上的构造函数
@重载的构造函数必须有不同的参数
@两个构造函数的参数必须是不同的
@实例变量有默认值，原始的默认值是0/0.0/false，引用的默认值是null
调用父类构造方法是用super（）；
如果我们没有调用super（）会发生什么？
编译器会帮我们加上super（）的调用。
所以编译器有两种涉入构造函数的方式：
1如果你没有编写构造函数
public ClassName(){
super();
}
2.如果你有构造函数但是没有调用super();
编译器帮忙假的一定回事没有参数的版本，假设弗雷有多个重载版本，也只有无参数的这个版本会被调用到。
父类的部分必须在子类创建完成之前就必须完整的成型。
对super()的调用必须是构造函数的第一个语句
public Boop(int i){
size = i;
super(); 错！ super（）调用必须是第一个语句!!
}
public Boop(){ 这样都行
}
public Boop(int i){
size = i；
}
使用this()来从某个构造函数调用同一个类的另外一个构造函数。换句话说this 就是个对对象本身的引用。
this() 只能被用在构造函数中，且必须是第一行语句。
super()与this()不能兼得.
每个构造函数可以调用super()或this()，但是不能同时调用
class Mini extends Car{
Color color;
public Mini(){
this(Color.red); 无参数的构造函数以默认的颜色调用真正的构造函数
}
public Mini(Color c){
super("Mini"); 这才是真正的构造函数
color = c;
}
public Mini (int size){
this(Color.red); 有问题！！不能同时调用super()和this()，两者只有一个会是第一行语句
super(size);
}
}
"变量的声明周期如何影响对象的声明周期？"
如果对象的唯一引用死了，对象就会从堆中被踢开。
有3种方法可以释放对象的引用：
1.引用永久性的离开它的范围。
void go(){
life z = new Life();
}
2.引用被赋值到其他的对象上。
Life z = new Life();
z= new Life();
3.直接将引用设定为null
Life z = new Life();
z = null;