08局部变量和成员变量\构造方法,方法的重载\this指针\static关键字

一、局部变量和成员变量

定义在方法中的变量为局部变量

区别：

/*
区别
    - 声明位置不同 类中 方法中
    - 作用范围不同: 当前类的方法 当前方法
            不同的方法中即使有相同的局部变量, 没有关系, 互不影响, 建议相同
    - 内存存放的位置: 局部变量栈内存中 成员变量堆内存中
    - 成员变量有默认值; 局部变量没有默认值
*/

/*
* 变量：
*   局部变量：
*       定义在方法中的变量称之为局部变量
*           作用域：从定义的位置开始到整个方法结束
*           局部变量不包含默认值，如果没有使用当前变量的话，可以不赋值
*           注意：局部变量只能在当前方法中使用，其他地方无法使用
*   成员变量：
*       定义在方法外，类内的变量叫做成员变量（全局变量）
*       成员变量包含初始值：int 0 String null boolean false
*           作用域：整个类体内
*
* */

public class VarDemo {
    int age = 20;

   public void test(){
       System.out.println(age);
       age = 10;
       System.out.println(age);
       int age = 30;
       System.out.println(age);
   }
    public void show(){
        //局部变量
        int a ;
        String name = "zhangsan";
        System.out.println(age);
//        System.out.println(a);
    }


    public static void main(String[] args) {
       VarDemo vd = new VarDemo();
        System.out.println(vd.age);
        vd.test();
        System.out.println(vd.age);


    }
}

 二、构造方法 

/*
访问修饰符 构造方法名 ( ) { //可以指定参数
 //初始化代码
}
*/
// 系统提供默认无参构造方法
public Penguin() {

}

/*
*   创建对象的时候默认会调用构造方法来创建对象，（在堆中开辟空间），可以完成成员变量的某些初始化操作
*   构造方法的语法：
*       方法名称：构造方法的方法名称必须跟类的名称保持一致
*       访问修饰符：后面讲
*       形参：可以用户自定义添加，跟方法的普通参数一样
*       方法体：完成对象的初始化功能
*       返回值：没有返回值
*/

1、构造方法重载

/*
*       1、创建完类之后，如果没有手动调用构造方法，会有一个默认的无参的构造方法供调用
*       2、当用户自定义了构造方法之后，默认的无参构造方法就不能够使用了，必须要手动定义无参构造方法
*       3、同一个类中可以包含多个同名的构造方法
*
*   重载：在一个类中可以包含多个重名的方法，但是注意方法的参数列表不能相同
*       三个方面的不同：
*           参数的个数不同
*           参数的类型不同
*           参数的顺序不同
*       注意：
*           一般构造方法都会进行重载（一个类中可能包含多个属性值，当只需要给部分属性初始化的时候需要调用不同的构造方法）
* */

自定义构造方法：

public class Teacher {

    String name;
    int age;

    public Teacher(){

    }

    public Teacher(String xname){
        System.out.println("one argument");
        name = xname;
    }
    //构造方法
    public Teacher(String xname,int xage){
        System.out.println("two argument");
        System.out.println("new......");
        name = xname;
        age =xage;
    }

    public void teach(String a,int b){

    }

    public void teach(int b,String a ){
        System.out.println("上课");
    }

    public static void main(String[] args) {
        Teacher teach = new Teacher();
        teach.name="连";
        teach.age=18;
        System.out.println(teach.name);
        System.out.println(teach.age);
        Teacher teacher2 = new Teacher("lisi",29);
        System.out.println(teacher2.name);
        System.out.println(teacher2.age);
        Teacher t3 = new Teacher("wangwu");
        System.out.println(t3.name);
    }
}

打印结果为:

/*
20
20
10
30
10
*/

▪构造器定义：constructor 构造方法

　　– 一个在创建对象时被自动调用的特殊斱法。

▪构造器作用：

　　– 为对象迚行初始化（成员变量）工作。

▪构造器是一种特殊的方法：

　　-  构造器的方法名必须和类名一致

　　– 造构器虽然有返回值，但是不能定义返回类型(返回值的类型肯定是本类), 不能在构造器里调用return 

　　-  通过new关键字调用！！

　　-  如果我们没有定义构造器，则系统会自动定义一个无参的构造方法。如果已定义则编译器不会添加无参数构造方法

　　– 与普通方法一样，构造方法也可以重载

示例1:

/*
▪定义一个“点”（Point）类用来表示二维空间中的点（有二个坐
标）。要求如下：
–可以生成具有特定坐标的点对象。
–提供可以设置二个坐标的方法。
–提供可以计算该“点”距另外点距离的方法。
*/

public class Point {
    int x;
    int y;

    //设置二维的坐标点
    public void set(int xx,int yy){
        x = xx;
        y = yy;
    }

    public double calcDistance(Point p){
        return Math.sqrt((p.x-x)*(p.x-x)+(p.y-y)*(p.y-y));
    }

    public void changePoint(Point p){
        int a = p.x;
        p.x = x;
        x = a;
        int b = p.y;
        p.y = y;
        y = b;
    }

    public void show(){
        System.out.println("["+x+","+y+"]");
    }

    public static void main(String[] args) {
        Point p1 = new Point();
        p1.set(3,5);
        Point p2 = new Point();
        p2.set(2,4);
        System.out.println(p1.calcDistance(p2));
        p1.changePoint(p2);
        p1.show();
        p2.show();

    }
}

打印结果为:

/*
1.4142135623730951
[2,4]
[3,5]

Process finished with exit code 0
*/

示例2:

/*
代码实现交换point中两个坐标的值（实现用对象作为参数）
*/

三、this关键字

• this的作用:

• • this表示的是当前对象本身，
  • 更准确地说，this代表当前对象的一个引用。

• 普通方法中使用this。

• • 区分类成员属性和方法的形参.
  • 调用当前对象的其他方法（可以省略）
  • 位置：任意

• 构造方法中使用this。

• • 使用this来调用其它构造方法
  • 位置：必须是第一条语句

• this不能用于static方法。（讲完static，大家就知道为什么了！）

public class ThisDemo {

    String name;
    int age;

    public ThisDemo(){

    }

    public ThisDemo(String name){
        System.out.println("one");
        this.name = name;
    }

    public ThisDemo(String name,int age){
        this(name); // 调用 上面的构造方法
        System.out.println("two");
        this.age = age;

    }

    public void test1(){
        System.out.println("test1");
        this.test2("hehe");
    }
    public void test2(String name){
        System.out.println("test2");
        test1();
        System.out.println(name);
        System.out.println(this.name);
    }


    public static void main(String[] args) {
        ThisDemo td = new ThisDemo("zhangsan",12);
        System.out.println(td.name);
        System.out.println(td.age);
        // td.test2("lisi");
    }

}

打印结果:

/*
one
two
zhangsan
12

Process finished with exit code 0
*/

四、static关键字

/*
* static:
*       修饰成员变量的时候，表示静态成员变量或者叫类变量
*           普通变量在使用的时候，必须要通过对象名进行调用
*           类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
*       修饰方法的时候，表示静态方法或者叫类方法
*           普通方法在使用的时候，必须要通过对象名进行调用
*           类方法或者静态方法可以使用类名，也可以使用对象名
*       注意：
*           1、静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
*           2、静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
*           3、成员变量放在堆中，而静态变量放在方法去中静态区
*           4、静态变量不能定义在静态方法中
*           5、静态方法可以在非静态方法中进行调用
*           6、静态方法中不能直接调用非静态方法
*           7、静态方法中不允许出现this调用
*           8、一般工具类中的方法定义为static
* */

1、修饰成员变量

public class StaticDemo {

    String name = "zhangsan";
    static int age = 10;

    public static void main(String[] args) {
        StaticDemo staticDemo = new StaticDemo();
        //使用对象进行调用
        System.out.println(staticDemo.name);
        System.out.println(staticDemo.age);//10

        //使用类名调用
        System.out.println(StaticDemo.name);
        System.out.println(StaticDemo.age);

    }
}

public class StaticDemo {

    String name = "zhangsan";
    static int age = 10;

    public static void main(String[] args) {
        StaticDemo staticDemo = new StaticDemo();
        //使用对象进行调用
        System.out.println(staticDemo.name);
        System.out.println(staticDemo.age);//10

        staticDemo.age = 20;
        System.out.println(staticDemo.age);//20
        System.out.println(StaticDemo.age);//20

        StaticDemo.age = 30;
        System.out.println(staticDemo.age);//30
        System.out.println(StaticDemo.age);//30

        StaticDemo staticDemo1= new StaticDemo();
        System.out.println(staticDemo1.age);//30
        //使用类名调用
        System.out.println(StaticDemo.name);
        System.out.println(StaticDemo.age);
    }
}

不允许在类中的方法内，用static

public class StaticDemo {

    String name = "zhangsan";
    static int age = 10;

    public static void test(){
//        test2();
//        new StaticDemo().test2(); 删掉 
//        static int a = 10;
    }

    public void test2(){
        System.out.println("non-static");
    }
    public static void main(String[] args) {
//        StaticDemo staticDemo = new StaticDemo();
//        //使用对象进行调用
//        System.out.println(staticDemo.name);
//        System.out.println(staticDemo.age);//10
//
//        staticDemo.age = 20;
//        System.out.println(staticDemo.age);//20
//        System.out.println(StaticDemo.age);//20
//
//        StaticDemo.age = 30;
//        System.out.println(staticDemo.age);//30
//        System.out.println(StaticDemo.age);//30
//
//        StaticDemo staticDemo1= new StaticDemo();
//        System.out.println(staticDemo1.age);//30
        //使用类名调用
//        System.out.println(StaticDemo.name);
//        System.out.println(StaticDemo.age);

//        StaticDemo sd = new StaticDemo();
//        sd.test();
//        StaticDemo.test();
//        sd.test2();

        StaticDemo staticDemo = null;
        staticDemo.test2();

    }
}