方法与方法重载

带参数的方法

1、定义带参数的方法
访问修饰符 返回类型 方法名（形式参数列表）{
//方法的主体
}
2、调用带参数的方法
对象名.方法名（参数1,参数2…参数n）

public void zha(String fruit){
    System.out.println(fruit+"汁");
    }
public void zha(String fruit,int cup){
    System.out.println(cup+"杯"+fruit+"汁");
    }
public static void main(String[] args) {
     Machine m =new Machine();
     m.zha("苹果");
     m.zha("苹果",2);
    }

运行

综合案例

添加学生姓名，指定区间查找

public class Students {
    public String[] names=new String[5];//属性名 names  类型是String[]
    public void addName(String name){
        int flag=0;//标志位来判断数组空间已满
        for (int i = 0; i < names.length; i++) {
            if (null==names[i]){
                names[i]=name;
                System.out.println(name+"成功进班，学号是："+(i+1));
                flag++;
                break;
            }
        }
        if (flag==0) {
            System.out.println("当前班级已满，请下次预定");
        }
    }
    public void show(){
        System.out.print("[");
        for (int i = 0; i < names.length; i++) {
            if (null==names[i]){
                System.out.print("]");
                break;
            }else if (i==names.length-1){
                System.out.println(names[i]+"]");
                break;
            }
            System.out.print(names[i]+",");
        }
    }
    public  int search(String name,int start,int end){
        if (name==null) {
            return -names.length;
        }
        int num=-1;//start end 是数组的下标
        if (start<0 ||end>=names.length||start>end){
            return -1;
        }
        for (int i = start; i <=end; i++) {
            if (name.equals(names[i])){
                num=i;
            }
        }
        return num;
    }
}

public class TestStudents {
    public static void main(String[] args) {
        Students ss= new Students();
        ss.addName("赵琪");
        ss.addName("王哲");
        ss.addName("黄哲");
        ss.addName("陈星杰");
        ss.addName("zzz");
        ss.addName("sss");
        ss.show();
        String a="dddd";
        int  rst=ss.search(a,1,4);
        System.out.println(rst==-1?"未找到该学员"+a:rst==-1*ss.names.length?"输入不能为空":"在下标"+rst+"处找到"+a);
    }
}

对象数组

public class Student {
    public String name;
    public int num;
    public int age;
    public  String  gender="男";
    public int score;
    public void show(){
        System.out.println("我叫"+name+"，学号是："+num+",今年"+age+"岁，我是"+gender);
    }
}

public class TestStu {
    Student[] stus = new Student[5];//创建对象数组
    public void addStudent(Student a){
        int flag=0;
        for (int i = 0; i < stus.length; i++) {
            if (null==stus[i]){
                stus[i]=a;
                flag++;
                break;
            }
        }
        if (flag==0){
            System.out.println("满了");
        }
    }
    public void print(){
        for (Student s : stus) {
            if (s==null){
                break;
            }
            s.show();
        }
    }

    public static void main(String[] args) {
        TestStu tStu = new TestStu();
        Student stu = new Student();
        tStu.addStudent(stu);
        stu.name="zzz";
        stu.age=15;
        stu.num=1;
        tStu.print();
    }
}

参数传递

     public class Test {
         public void calc1(int num){
                  num=num+1;
          }
          public void calc2(Student student){
                  student.age=student.age+1;
          }
}

//测试类
Test test=new Test();
int n=8;
test.calc1(n);
Student stu=new Student();
stu.age=18;
test.calc2(stu);
System.out.println(n+"---"+stu.age);

输出结果是8–19
如果是基本数据类型，传递的是值；
如果是引用数据类型，传递的是地址

public class Demo1 {
    /**
     * 要对学员数组进行分数求和，求平均值，判断平均值
     * 小于60，对象中每个元素的分数都+2
     * @param stus 对象数组，数组中的每一个元素是该类型的对象
     *              正常需要判空
     */
    public void addScores(Student[] stus){
        //判断数组是否为空
        if (null==stus) {
            System.out.println("数组为空，没有成绩");
            return;//break是跳出循环、switch
        }
        int sum=0;
        int cnt=0;
        for (int i = 0; i < stus.length; i++) {
            //找出每个对象 找出对象的成绩 求和
            if (null==stus[i]){
                continue;
            }else {
                sum+=stus[i].score;
                cnt++;
            }
        }
        double avg=sum/(double)cnt;
        if (avg<60){
            for (int i = 0; i < stus.length; i++) {
                if (null==stus[i]) {
                    continue;
                }else{
                    stus[i].score+=2;
                }
            }
        }


    }

    public static void main(String[] args) {
        Demo1 d= new Demo1();
        Student[] s=new Student[5];
        for (int i = 0; i < s.length; i++) {
            s[i]=new Student();
            s[i].score=(int)(Math.random()*60);
        }
        for (Student i : s) {
            System.out.print(i.score+",");
        }
        System.out.println();
        d.addScores(s);
        for (Student i : s) {
            System.out.print(i.score+",");
        }
    }
}

构造方法-对象初始化

1、系统默认提供无参构造方法

 String username;
 public User(){
     System.out.println("这是无参构造方法");
    };
User u =new User();

2、当类中定义了构造方法，原先的默认构造方法不再提供

public class User {
    String username;
//    public User(){
//        System.out.println("这是无参构造方法");
//    };
    public User(String name){
        username=name;
    }
    //只要在类中定义了构造方法，原先系统默认的无参构造方法不再提供
    public static void main(String[] args) {
        User u =new User();
        User user = new User("张");
        System.out.println(user.username);

    }
}

User u =new User(); 提示：报错
3、构造方法的结构：
无返回值类型
方法名和类名相同
可以指定参数
public 类名(){
代码
}

this关键字

public Batman(int attack, int defence, int health, String name) {
        this.attack = attack;
        this.defence = defence;
        this.health = health;
        this.name = name;
    }

带参构造方法this关键字是对一个对象的默认引用这里用以区分同名成员变量
1、调用属性
this.health=“11”;
2、调用方法
this.print();
3、调用构造方法
this（）；
this（111,222,333，“ss”）；如果使用，必须是构造方法中的第一条语句

方法重载

同一个类中
方法名相同
参数列表不同（参数个数、类型、顺序）
与返回值、访问修饰符无关

public int cal(int a,int b){
        return a+b;
    }
public double cal(double a,double b,double c){
        return a+b+c;
    }

成员变量和局部变量

变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域
作用域不同：
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同：
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
在同一个方法中，不允许有同名局部变量
在不同的方法中，可以有同名局部变量
在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级