Java 入门探索者06（权限修饰符，实参形参，调用方法，值传递，引用传递，全局变量，引用变量）

Java中有四个权限修饰符，用于控制类、方法和变量的访问权限：

1. public: 公共访问权限，被public修饰的类、方法和变量可以被任意包中的类访问。

2. protected: 受保护访问权限，被protected修饰的类只能被同一包中的类以及不同包中的子类访问。被protected修饰的方法和变量只能被同一包中的类和不同包中的子类访问。

3. default (默认): 默认访问权限，即不使用任何关键字修饰。被默认修饰的类、方法和变量只能被同一包中的类访问。

4. private: 私有访问权限，被private修饰的类、方法和变量只能被同一类中的其他方法访问，不同类中的方法都无法访问。

这些权限修饰符可以用来限制对类、方法和变量的访问，从而提供了一定的安全性和封装性。在设计类和对象的时候，根据需求选择合适的访问权限修饰符可以更好地控制访问权限和提高代码的可维护性。

public class Demo {
    public static void main(String[] args) {
        Student s = new Student();
        //在同一个类中，四个权限修饰符修饰的变量都可以访问到
        //在同包下的不同类中，除了private修饰的变量外都可以访问到
        System.out.println(s.no);
        System.out.println(s.name);
        System.out.println(s.age);
        //System.out.println(s.javaScore);
    }
}

在Java中，实参和形参是方法中的两个重要概念。

形参（parameter）是指在方法定义中声明的变量，用于接收方法调用时传递过来的值。形参的作用是给方法提供一个占位符，在方法的执行过程中可以使用这个参数进行相关的操作。形参一般由方法的定义者指定，可以有多个形参，每个形参都有自己的数据类型和名称。

实参（argument）是指在方法调用中传递给方法的值。实参的作用是为方法的形参提供具体的值，实际上是方法的调用者根据方法定义者的要求给出的值。实参的个数和顺序必须与方法定义中的形参一致，数据类型也必须匹配。

当一个方法被调用时，实参的值会被传递给方法中对应的形参，方法会使用这些实参的值进行相应的操作。通过这种方式，方法的调用者可以在方法的执行过程中向方法传递信息或数据。方法执行完毕后，形参的作用就结束了，而实参的值不受影响。

总结起来，形参是方法定义中声明的变量，用于接收方法调用时传递过来的值，而实参是方法调用时传递给方法的具体值。形参和实参的作用是在方法的调用过程中传递信息和数据。

//形参：方法定义时写在方法括号里的参数，没有真实的值
//实参：方法调用时写在方法括号里的参数，有真实的值
//规则：永远都是实参给形参赋值
public class Number {
    public void swap(int x,int y){
        int temp;
        temp=x;
        x=y;
        y=temp;
    }

    public static void main(String[] args) {
        int a= 5,b=9;
        Number n =new Number();
        n.swap(a,b);
        System.out.println("a+"+a+"b+"+b);
    }
}

在Java中，调用方法的方式有三种：

1. 调用对象的实例方法：
   通过创建对象的实例，然后使用对象名称加点操作符来调用方法。例如：
   ```java
   MyClass myObject = new MyClass();
   myObject.myMethod();
   ```

2. 调用静态方法：
   静态方法是属于类本身的，而不是类的实例。可以直接使用类名称加点操作符来调用静态方法。例如：
   ```java
   MyClass.myStaticMethod();
   ```

3. 调用方法时传递参数：
   在调用方法时，可以传递参数给方法。参数可以是基本数据类型、对象或数组。例如：
   ```java
   int sum = myObject.calculateSum(5, 10);
   ```
   以上示例中，`calculateSum`方法接收两个整数参数，并返回它们的和。

无论是调用对象的实例方法还是静态方法，都可以通过方法名称加括号的方式来调用方法。

public class Student {
    //写一个标准的封装类
    //四个属性分别是 no name age javaScore
    //类型为 int String int double
    //写出其get方法和set方法
    //写出java程序的运行入口
    //在入口处用两种创建对象的方式创建两个对象
    public int no;
    protected String name;
    int age;
    private double javaScore;
    public int getNo(){
        return no;
    }
    public void setNo(int theNo){
        no = theNo;
    }
    public String getName(){
        return name;
    }
    public void setName(String theName){
        name = theName;
    }

    public int getAge(){
        return age;
    }
    public void setAge(int theAge){
        age = theAge;
    }
    public double getScore(){
        return javaScore;
    }
    public void setScore(double theScore){
        javaScore = theScore;
    }

    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2;
        student2 = new Student();
        //java调用属性的方式为对象名.属性名
        System.out.println(student1.no);
        //java调用方法的方式为对象名.方法名
        System.out.println(student1.getNo());
        student1.no=1001;
        System.out.println(student1.no);
        System.out.println(student1.getNo());
        student1.setNo(1005);
        System.out.println(student1.no);
        System.out.println(student1.getNo());

        Student s = new Student();
        //在同一个类中，四个权限修饰符修饰的变量都可以访问到
        System.out.println(s.no);
        System.out.println(s.name);
        System.out.println(s.age);
        System.out.println(s.javaScore);
    }
}

值传递和引用传递是两种不同的参数传递方式，用于将数据传递给函数或方法。

值传递是指将参数的值复制一份传递给函数或方法。在函数内部对参数进行修改不会影响原始数据的值。这是因为在函数内部使用的是参数的副本，而不是原始数据本身。值传递适用于简单数据类型，如整数、浮点数和布尔值等。

引用传递是指将参数的引用（内存地址）传递给函数或方法。在函数内部对参数进行修改会影响原始数据的值。这是因为在函数内部使用的是原始数据本身，而不是副本。引用传递适用于复杂数据类型，如数组、列表和对象等。

需要注意的是，虽然在引用传递中可以修改原始数据的值，但是如果在函数内部修改了参数的引用，即将参数指向了新的内存地址，则不会影响原始数据。

选择值传递还是引用传递取决于需求和数据类型的特性。值传递适用于需要在函数内部独立操作参数值的情况，而引用传递适用于需要在函数内部修改原始数据的情况。

//值传递：传递的是八种基本数据类型，传递后不会对原来的变量有任何影响
//引用传递：传递的是引用类型的数据，传递之后会对原来的变量有影响
public class Test {
    public void test(Student student){
        student.setNo(1001);
        student.setName("张三");
        student.setAge(18);
        student.setScore(99.5);
    }

    public static void main(String[] args) {
        Student s = new Student();
        Test t= new Test();
        s.setNo(1002);
        s.setName("李四");
        s.setAge(20);
        s.setScore(59.5);
        t.test(s);
        System.out.println(s.getNo());
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getScore());
    }
}

在Java中，变量可以分为全局变量和局部变量。

全局变量是在类中声明的变量，它们可以在整个类中访问。全局变量在声明时可以赋初值，如果没有赋值，它们的默认值会根据变量的类型而定。全局变量可以在类的任何方法中使用，包括构造方法和其他方法。全局变量在类的所有实例中都是共享的，即同一个类的不同对象中的全局变量是相同的。

局部变量是在方法、构造方法或代码块中声明的变量，它们只能在声明它们的方法、构造方法或代码块中使用。局部变量在声明时必须赋初始值，否则会编译错误。局部变量的作用范围只限于声明它们的方法、构造方法或代码块。局部变量在方法、构造方法或代码块执行完后会被销毁，它们在每次调用方法时都会重新创建。

全局变量和局部变量可以具有相同的变量名，但是在同一作用域内，局部变量的优先级高于全局变量。当有相同名称的局部变量和全局变量时，局部变量会屏蔽全局变量，即在该作用域内会优先使用局部变量。如果需要在局部作用域内访问全局变量，可以使用关键字`this`来引用全局变量。

public class Variable {
    //写在类中的变量就是成员变量也叫属性还叫全局变量
    int age = 10;
    public void doSomething(){
        //写在方法或者语句块中的变量就是局部变量
        int no;
        //成员变量会默认初始化
        System.out.println(age);
        //局部变量必须要先进行初始化才能使用，否则编译报错
        no=1001;
        System.out.println(no);
    }
    public void saySomething(){
        //成员变量和局部变量同名的时候，局部变量会将全局变量屏蔽掉
        int age = 10;
        //成员变量在整个类中都可以使用
        System.out.println(age);
        //局部变量只能在定义他的方法或者语句块中使用
        //System.out.println(no);
    }
}