第三周 Day2

 

1.局部变量和成员变量的区别

class Text{
    public int num2 = 200;//类中方法外,成员变量
    
    public void show(String str){
    //str,num都是局部变量(方法定义中或者方法声明上)
    int num = 100;
    System.ouy.println(str+num);
}
}
​
​
区别:
    1)书写位置不同
        局部变量:在方法定义中或方法生命上
        成员变量:在类中方法外(范围大)
    2)内存中的位置不同
        局部变量:在栈内存中
        成员变量:在堆内存中
    3)访问方式不同
    4)生命周期不同
        局部变量:随着方法调用而存在,随着方法调用结束而结束
        成员变量:随着对象的创建而存在,跟对象有关--类名 对象名 = new 类名();随着对象的创建完毕等待垃圾回收器空闲的时候回收而消失;
    5)初始化值不同
        局部变量:要么先定义,后面初始化;要么直接初始化
                在使用之前必须初始化,否则报错
        成员变量:存在系统默认初始化,可以赋值,可以不赋值,但是一般不会直接赋值,都是通过 对象名.成员变量 = 赋值;
        

2.方法形参问题

形式参数如果是基本数据类型,形参的改变不会影响实际参数

idea中的快捷键:alt+enter----代码提示,补全代码,导包
​
public class Test {
    public static void main(String[] args) {
​
        //有两个变量
        int a = 10 ;
        int b = 20 ;
​
        System.out.println("a:"+a+",b:"+b) ;//10,20
        change(a,b) ;//实际参数
        System.out.println("----------------------") ;
        System.out.println("a:"+a+",b:"+b) ;//10,20
    }
    
    private static void change(int a, int b) { //形式参数是基本数据类型--局部变量的生命周期随着方法的调用而存在,随着方法调用结束而消失
        System.out.println("a:"+a+",b:"+b) ;//10,20
        a = b ;  //形参改变
        b = a+ b ;
        System.out.println("a:"+a+",b:"+b) ;//20,40
    }
}
​

如果形式参数是引用数据类型,(数组,类,接口),他们作为形式参数,形式参数的改变会直接影响实际参数,他们都是空间地址值传递
​
形式参数的改变直接影响了实际参数;

public class Test2 {
    public static void main(String[] args) {
​
        //创建一个数组,静态初始化
        int[] arr = {1,2,3,4,5} ;
​
        System.out.println(arr[1]) ; //2
        change(arr) ;//实际参数传递----数组对象----new出来的东西  空间地址值
        System.out.println(arr[1]) ;//4
    }
​
    //形式参数是引用数据类型,数组
    public static void change(int[] arr) { //数组,引用数据类型 ---形式参数是数组类型
        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            if(arr[x] % 2== 0){
                arr[x] *=2 ;
            }
        }
    }
}
​

String作为引用数据类型,是一种特殊的引用类型,
    它作为形式参数的效果和基本类型是一致的,
    形参的改变不会影响实际参数
    因为字String是常量  String str = "abc";

public class Test3 {
    public static void main(String[] args) {
​
        //定义一个字符串
        String str = "hello" ;
        System.out.println("str:"+str);//str:hello
        change(str) ;
        System.out.println("---------------------") ;
        System.out.println("str:"+str);//str:hello
    }
​
    //change方法
    public static void change(String str) { //形式参数是String类型
        System.out.println(str) ;//hello
        str += "高圆圆" ;
        System.out.println(str) ;//hello高圆圆
    }
}
​

后面的面向对象研究的都是引用数据类型

//定义一个学生类
class Student{
    //成员方法
    public void study(){
        System.out.println("Good Good Study ,Day Day Up!!!");
    }
}
//StudentDemo类
class StudentDemo{
    //成员方法
    public void method(Student student){//形式参数Student类型,引用类型
        student.study() ;//什么才能访问学生类的study方法呢?
                        //学生对象才能访问study方法呀!!
                        //实际参数需要创建Student类对象才能访问study()
                        //下面的实际参数就是s---代表学生对象
                        //s.study() ;
    }
}

//测试类
public class StudentTest {
    public static void main(String[] args) {
        //需求:调用StudentDemo类中的method方法?如何访问呢?
        //1)创建StudentDemo类对象
        StudentDemo studentDemo = new StudentDemo() ;
        //一看到,当前method方法中有一个Student类型,所以需要创建Student类的对象
        Student s = new Student() ;
        studentDemo.method(s);//实际参数,形式参数是Student类型
    }
}
​

3.匿名对象

匿名对象:没有名字的对象
有名字格式:
        类名 对象名 = new 类名();
        Student 是= new Student  s----就是对象名
匿名对象的格式:
        new 类名();
匿名对象的好处:
        1)实际开发中,匿名对象不要多次,使用一次即可,使用完毕,会被垃圾回收器回收(因为没有栈内存指向堆堆内存地址)
        2)匿名对象可以作为参数传递
        3)从内存角度考虑,节省内存

3.1匿名对象的使用

//老师类
class   Teacher{
    //成员方法
    public void love(){
        System.out.println("爱生活,爱Java,爱高圆圆!!");
    }
}
//定义TeacherDemo类
class TeacherDemo{
    //成员方法
    public void function(Teacher t){//形式参数是一个引用类型---老师类
        t.love() ;
​
        //Teacher teacher = new Teacher() ;teacher是实际参数
        //teacher.love() ;
    }
}
​
       

//测试类
public class NoNameDemo {
    public static void main(String[] args) {
        //要访问TeacherDemo类中的function方法,而且实际参数应该怎么传递
        //1)创建一个TeacherDemo类对象
        TeacherDemo td = new TeacherDemo() ;
        //观察:上面的function方法的形式参数是一个Teacher类型,需要传递实际参数:是Teacher类对象
​
        Teacher teacher = new Teacher() ;//空间地址值
        td.function(teacher) ;
​
        System.out.println("----------------------------------------");
​
        //使用匿名对象操作:
        //匿名对象的格式是什么: new 类名() ;
        //要访问TeacherDemo类中的function方法
        //1)创建一个TeacherDemo类对象
        TeacherDemo td2 = new TeacherDemo() ;
        td2.function(new Teacher());
​
        System.out.println("----------------------------------------");
​
        //继续优化:
        //要访问TeacherDemo类中的function
        //链式编程(仅仅是自己玩一下可以,实际开发中,尽量明细步骤来!)
        new TeacherDemo().function(new Teacher());
​
    }
}
​

4. this关键字

场景:成员变量和局部变量一致,局部变量隐藏了成员变量,引入关键字--this--区分成员变量和局部变量;
this:代表了当前类对象的地址值引用
    this.变量名
    this.name = name