关键字

this

对象创建过程：

• 1.在栈建立栈帧，分配对象空间，对象成员变量初始化为0或空。

• 2.执行属性值的显示初始化。

• 3.执行构造方法。

• 4.返回对象地址值，关闭栈帧。

this本质：对象地址值

构造方法调用前，对象已经创建。所以在构造方法中this代表当前对象。

常用用法：

• 1.this指代当前对象;普通方法的this指调用该方法的对象。构造方法的this总指正要初始化的对象（本类）。

• 2.使用this关键字调用重载的构造方法，只能在构造方法中用，必须位于构造方法的第一句。

• 3.this不能用于static方法中。

• 4.区分成员变量和局部变量。

示例：

package com.itcode.demo;  

/**      
 * @author: 成都码到功成学员  
 * @Description: this关键字 
 *  
 */  
public class TestThis {  
    int a;  
    int b;  
    int c;  

    //无参构造  
    public TestThis(){  

    }  
    //有参参构造  
    public TestThis(int a, int b){  
//      TestThis()//无法这样用。  
        System.out.println(a+b);  
    }  

    public TestThis(int a, int b, int c){  
        this(a, b);// 调用有参/无参。//构造方法中用，必须位于构造方法的第一句。  
        this.c = c;  

    }  
    public void study() {  
        System.out.println("成都码到功成学习");  
    }  

    void eat() {  
        this.study();// 调用本类方法  
        System.out.println("睡觉");  
    }  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
//      System.out.println(this);//  this不能用于static方法中  
        new TestThis().eat();  
    }  

}

效果：

static

特点：

随着类的加载而加载。

优先于对象存在。

被类的所有的对象所共享。

可以通过类名(推荐)和对象名访问。

静态只能访问静态，非静态可访问静态非静态。

static位置：只能在成员属性成员方法（或者成员内部类）上，被static修饰的成员变量和成员方法属于类。

示例:

package com.itcode.demo3;  

/** 
 * @Auther: 成都码到功成学员 
 * @Description: 
 * 测试static 
 */  
class StaticTest{  
    // 属性  
    int age;  
    String name = "码到功成";  
    static String job = "java";  
    // 普通方法  
    public void work(){  
        System.out.println("工作");  
    }  
    // 普通方法  
    public void work1(){  
        // 普通方法可以调用静态方法属性和普通方法属性。  
        work();  
        study();  
        System.out.println(name+job);  
        System.out.println("工作");  
    }  
    // 静态方法  
    public static void study(){  
        // 静态方法只能调用静态方法属性。  
//        System.out.println(name);报错  
        System.out.println(job);  
        System.out.println("学习");  
    }  
}  
public class TestStatic {  

    // main方法是比较出名且典型的静态方法。  
    public static void main(String[] args) {  
        StaticTest t = new StaticTest();  
        // 基本方法数组必须创建对象才能调用  
        t.work();  
        System.out.println(t.name);  
        // 静态属性与方法可以通过对象名和类名调用。  
        // 类名调用(建议)  
        StaticTest.study();  
        System.out.println(StaticTest.job);  
        // 对象名调用  
        System.out.println(t.job);  
        t.study();  
    }  
}

效果:

代码块

• 含义：用花括号圈起来的内容。

• 分类：局部,构造,静态,同步代码块(多线程讲解)

局部代码块

• 位置: 在局部位置(在方法定义中)

• 作用: 限定变量的生命周期（作用域）,提早释放内存,提供内存的利用率

构造代码块: (构造方法//public开头 （分为无参，带参）)

• 位置: 在成员位置(在类中方法外)

• 特点: 给所有对象进行统一的初始化，每创建一次对象,都需要调用一次.并且优先于构造方法执行

• 作用: 我们可以把多个构造方法(对类初始化)都需要执行的代码,放在构造代码块中,这样就提高了代码的复用性

静态代码块: //static

• 位置: 在成员位置(在类中方法外) , 并且前面需要添加一个 static 关键字

• 特点: 随着类的加载而执行,只执行一次,优先于构造代码块执行,

• 作用: 完成类的初始化工作

构造方法用于对象的初始化，静态代码块用于类的初始化。

同步代码块:加synchronized关键修饰,为了线程安全。

执行顺序：

静态代码块依次顺序初始化Object——父类1——父类2……本类。

构造方法与上面一样。

示例:

package com.itcode.demo3;  

/** 
 * @Auther: 成都码到功成学员 
 * @Description: 
 * 代码块 
 */  
public class Testcode {  
    String name;  

    static {  
        System.out.println("静态代码块");  
    }  
    {  
        System.out.println("构造代码块");  
    }  
    public Testcode(String name) {  
        System.out.println("有参构造方法");  
        this.name = name;  
    }  
    public Testcode() {  
        System.out.println("无参构造方法");  
    }  
    public static void main(String[] args) {  
        {  
            System.out.println("局部代码块");  
        }  
        Testcode o = new Testcode();  
        Testcode o1 = new Testcode("码到功成");  

    }  
}

效果:

先执行静态代码块，然后进入main方法加载局部代码块。

再接下来就是构造代码块与构造方法。每调用一次构造方法之前都要调用一次构造代码块。

参数传递

概述：方法中参数传递都是值【值的副本】传递，副本改变不影响原件。

基本数据参数传递的是值的副本， 副本改变不影响原件。

引用类型参数传递的是值的副本，但是引用类型指的是“对象的地址”。副本和原件都指向同一个“地址值”，所以改变“副本”会影响对象的值。

简单来说，就是基本数据参数传递不会改变值，引用数据会。

示例

package com.itcode.demo;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 方法中中的引用类型参数传递问题。 
 *  
 */  
public class TestTransfer {  

    int id;  
    String name;  

    public TestTransfer() {  

    }  

    public TestTransfer(int id, String name) {  
        this.id = id;  
        this.name = name;  
    }  

    public void transferParam(TestTransfer transfer) {  
        transfer.name = "成都码到功成";  
    }  

    public void transferParam2(TestTransfer transfer2) {  
        transfer2 = new TestTransfer(114, "西部智谷");  
        System.out.println("transferParam2方法里面tranfer2的地址值："+transfer2);  
    }  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        /*   
          *  猜输出语句结果 
          *  第一个输出语句 
          * 当程序执行到"new TestTransfer(113, "光谷")"会把在内存开启空间，id=113 
         * name="光谷"，并把地址值15db9742给常量transfer1。 
          * 当程序执行到"transferParam(transfer1);"，会把transfer1的地址值赋给transferParam方法里面的参数transfer。 
         * transfer的地址值就是15db9742， 
         * transfer.name = "成都码到功成"就内存中地址值15db9742。 
          * 的name值改变为"成都码到功成"，所以第一个输出语句的结果就是 成都码到功成。 
         * ######################################################################### 
          * 第二个输出语句 
          * 继续往下执行，当程序执行到"transferParam2(transfer1);"时，会把transfer1的地址值赋给transferParam2方法里面的参数transfer2。 
          * 原本参数transfer2的地址应该是15db9742， 
          * 但执行到"new TestTransfer(114, "西部智谷");"产生一个新对象并把把它的地址值6d06d69c赋给参数transfer2 
         * transfer2地址值是6d06d69c，transfer1的地址值是15db9742。transfer2并没有改变15db9742里面id、name值。 
         * 都不是一个地址值。 
         * 它们两个没有任何关系，所以输出的transfer1.name值仍然为成都码到功成。 
         * */  
        TestTransfer transfer1 = new TestTransfer(113, "光谷");  
        System.out.println("tranfer1的地址值："+transfer1);  
        // 猜下面两个输出语句transfer1.name的结果  
        transfer1.transferParam(transfer1);  
        System.out.println(transfer1.name);// 成都码到功成  
        System.out.println("第一个'transfer1.name'里面tranfer1的地址值："+transfer1);  

        transfer1.transferParam2(transfer1);  
        System.out.println(transfer1.name);// 成都码到功成  
        System.out.println("第二个'transfer1.name'里面tranfer1的地址值："+transfer1);  

    }  


}

效果：

package

作用：管理类，解决多个同名类问题，同一个包不能出现同名类。

规范：一般在类的第一句

命名规则：com/cn.公司组织名.名字（根据包的功能命名），如com.itcode.test(test代表此包是测试包或者练习使用)。

Eclipse项目中使用package

• 1、点击src。

• 2、再点击上方工具栏图标出现New Java Package。

• 3、‘Name’框输入报名

• 4、点击Finish完成创建。

Java常用package介绍

包	说明
java.lang	Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.awt	抽象窗口工具集（abstract window toolkits），构建和管理应用程序的图形用户界面(GUI)。
java.net	执行与网络相关的操作的类。
java.io	提供多种输入/输出功能的类。
java.util	一些实用工具类，如定义系统特性、使用与日期日历相关的函数。

import

静态导入

作用：import导入要使用其他包的类，需要使用import导入，在本类中可直接通过类名来调用，不用书写类的完整包名和类名。

示例

package com.itcode.demo;  

//import com.itcode.demo1.TestStu;// 导入的包  


/**      
 * @author: 成都码到功成学员  
 * @description:  
  *  静态导入 
 */  

public class TestImport {  

    public static void main(String[] args) {  
        // 未导入包  
        TestStu stu = new com.itcode.demo1.TestStu();  
        // 导入包  
        TestStu stu1 = new TestStu();  
    }  
}