Javase 重要知识点总结 day06

关键词： 带参方法 可变参数

#1、成员变量和局部变量的区别
变量分类：
1.成员变量：在类中定义的。
1).实例成员变量
2).静态成员变量
##2.局部变量：在方法中定义的。
区别：

1. 作用域。
   成员： 整个类中 都有效；
   局部： 在声明它的方法中有效的。
2. 初始值。
   成员： 系统自动初始化；
   局部： 必须自己初始化，系统不管。
3. 优先级
   成员变量 和 局部变量同名，在局部变量作用域内，优先使用 局部变量。
   区分 : this.成员变量。

public class DemoMethod1 {
    // 成员变量
    int n1 = 11;
    public void f1() {
        int n2 = 11;
//      System.out.println(n1);// 0
        System.out.println(n2);
        
    }
    public void f2() {
        int n1 = 22;
        System.out.println(n1);//
        System.out.println(this.n1);
        
    }
    public static void main(String[] args) {
        new DemoMethod1().f2();
    }
}

方法调用：
不同类： 创建对象调用 new
同一个类： 可以使用 this,或者省略this;
主方法中main()调用 同一个类的 自定义方法，需要new 创建对象调用。
原因:主方法里面有 static

#2、带参方法定义

参数传递：

class Juicer{
    // 榨果汁
    public void jucing() {
        System.out.println("苹果汁喝了");
    }
    // 2
    public String jucing2() {
        return "苹果汁";
    }
    // 3.
    //                     形式参数：局部变量
    public String jucing3(String food) {// 
        return food + "汁";
    }
    //4.
    public String jucing4(String food1,String food2,int n) {
        return food1 + food2 + "汁";
    }
    
}
public class TestJuicer {
    public static void main(String[] args) {
        // 4
        Juicer j004 = new Juicer();
        String s = j004.jucing4("苹果", "西瓜", 56);
        System.out.println(s);
        // 3
/*      Juicer j003 = new Juicer();
//      String str = "西瓜";
        Scanner input = new Scanner(System.in);
        String str = input.next();
        //                              实际参数      
        System.out.println(j003.jucing3(str));*/
        
//      Juicer j001 = new Juicer();
//      j001.jucing();
//      Juicer j002 = new Juicer();
//      String str = j002.jucing2();
//      System.out.println("把" + str + "送给郭靖");
//      System.out.println("把" + str + "送给黄蓉");
//      str = str + "面粉";
//      System.out.println(str);
    }
}

#3、方法参数传递
##1、值类型
数据没有影响，因为是两个不同的对象空间。
（一个在main空间，一个在f1 方法的空间，f1的方法在运行完后-----------会弹出栈，里面的变量就会消失），所以下面案例中，再调用n时，只能输出main方法中的 22了。

2、引用类型
1） 两个引用 指向了 同一个对象。

注意：
1.正常的程序开发过程中，一个文件一个类，把所有的类放在一个文件包即package中，为了避免出错（可能在一个文件中出现重名啊之类的）。（当然也可以，一个文件中很多类，作用就是复习阅读，但是要注意类名不要重复）
实现一个文件中定义很多类：（他有自己的原则）
1.只能有一个public，而且public class 类名 ，类名必须有文件名一致
2.只有在public class定义的类 下，才能有main主函数
2）两个引用 指向了 不同对象。
案例：

原理：
||||||||

原理解读：
1)main主方法的字节码文件，加载到栈中，开始执行
2)new出一个test对象，对象类型是testparam，在堆内存中开辟一个空间，并将地址值传递给test
3)new出一个p对象，对象类型是param，在堆内存中开辟一个空间，并将地址值0x12a传递给p(换句话说，p里面存的就是一个地址值)
4)将11，赋值给p的成员变量value，然后p空间中的value值就是11了。
5)f2方法进栈内存，传参，param p=p,把地址值0x12a,传递给f2方法中的p
6)执行f2方法中的new操作，新开辟出一个空间，地址值记作为0x33a,
7)在新开辟空间的中存有成员变量和成员方法，把22赋值给空间中的成员变量value
8)完了之后，test.f2（p）方法，执行完成之后，会弹出栈，
9)再次调用P.value，只能输出0x12a地址里面的value值了。

#4、引用参数
1）5个数求和。

public class TestParamArr {
    public int sum(int [] arr) {// int [] arr = 1;
        int result = 0;
        for(int i = 0;i < arr.length;  i++) {
            result += arr[i];
        }
        return result;
    }
    
    public static void main(String[] args) {
        TestParamArr test = new TestParamArr();
        int [] arr = {1,2,3,4,5};
        int n = test.sum(arr);// int
        System.out.println(n);
    }
}

注意： int[ ] 这就是一个类型，数据类型（int 类型的数组），arr就是这个数据类型的数组
arr存储的就是数组{1,2,3,4,5}的地址值，本质上，传参传的是地址值，把arr（地址值）传递给sum中的参数。如图中的箭头所示。
3）定义一个数组，存储3名学员，编写方法计算学员的总成绩。

定义三个类，学生类：存储学生的基本信息，
方法类（功能类）：计算总成绩的方法，
测试类：创建对象，输入参数，运行结果
point：
1） 将数组[ ]作为一个参数，（以前数据太多，需要一个一个去 赋值对象的变量，现在可以把数据放进数组中），求和、取出相应索引的值及其他操作，可以进行遍历。
2）int num= new Manager().sum(stus);
//这个相当于 Manager mgs=new Manager(); int num=mgs.sum(stus); 两步操作合二为一了。
3）怎样把这些类，整合在一起，就是通过创建对象，把参数传递给对象中的方法，调用对象中的方法。
代码：

class Student{
    String name;
    int score;
    //…………………………
}
// 统计
class ManagerStu{
    // 总成绩
/*  public int sum(Student guojing,Student yangkang,Student huangrong) {
        return guojing.score + yangkang.score + huangrong.score;
    }*/
/*  public int sum(Student [] stus) {
        return stus[0].score + stus[1].score + stus[2].score;
    }*/
    public int sum(Student [] stus) {// Student [] stus = stus 0x 12a
        int r = 0;
        for(int i = 0; i < stus.length ; i++) {
            r += stus[i].score;
        }
        return r;
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Student guojing = new Student();
        guojing.score = 90;
        Student huangrong = new Student();
        huangrong.score = 100;
        Student yangkang = new Student();
        yangkang.score = 80;
        // 数组
        Student [] stus = {guojing,yangkang,huangrong};
        ManagerStu mgr = new ManagerStu();
        int n = mgr.sum(stus);// 地址
        System.out.println(n);
        
    }
}

#5、可变参数
语法: … arr //…数组名
作用: 传参灵活多样；
底层数据结构： 数组。
注意：

1. 可变参数 ，可以不传参，可以传递多个，也可以传递一个数组；//例如，图片中的24-26行代码
   数组 只能 传递 数组参数；
   2.可变参 只能有一个；
   数组可以定义多个；
   3.可变参数必须放在所有参数的最后边； //不然后一大堆参数，计算机不知道，你分配几个给可变参数…arr
   数组参数 可以放在任意位置。