Day05 Java基础3及方法复习

Day05 Java基础3及方法复习

方法

import java.util.Random;//导包
import java.util.Scanner;//导包

public class demo4 {
    public static void main(String[] args) {
        Random r = new Random();//创建对象
        int number = r.nextInt(100)+ 1;//获取随机数
        while(true){
            Scanner sc = new Scanner(System.in);//创建对象
            System.out.println("输入猜的数字");
            int guessNumber = sc.nextInt();//输入数字
            if(guessNumber > number){
                System.out.println("大了");

            }else if (guessNumber <number){
                System.out.println("小了");

            }else {
                System.out.println("中了");
            }
        }
    }
}
//随机数（彩票）

System.out.println("小了");//输出内容并换行
System.out.print("小了");//输出内容不换行
System.out.println();//起到换行的作用

public class demo05 {
    public static void main(String[] args) {
        int [] arr={11,22,33,44,55};//定义一个数组，静态初始化完成数组元素初始化
        printarray(arr);
    }
    public static void printarray(int[] arr) {
        System.out.print("[");
        for (int x=0; x< arr.length; x++){
            if(x == arr.length-1){
                System.out.print(arr[x]);
            }else{
                System.out.print(arr[x]+",");
            }
        }
        System.out.println("]");
    }//自己定义一个方法
}
//逻辑

public class demo06 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};//定义一个数组用静态初始化对数组元素初始化
        int number=getMax(arr);//调用获取最大值的方法，用变量接收返回结果
        System.out.println("最大值为"+number);//输出最大值
    }
    /*
    两个明确：返回值的类型：int、参数int[] arr
     */
    public static int getMax(int[] arr){
       int max=arr[0];
       for(int x=1;x< arr.length;x++){
           if(arr[x]>max){
               max=arr[x];
           }
       }
       return max;
    }
}
//利用方法获取最大值

---

Debug

• 查看程序的执行流程，也用于追踪程序执行过程来调试程序

---

综合小结练习

import java.util.Scanner;
public class demo07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建对象
        while (true){
            System.out.println("输入星期数");
            int week = sc.nextInt();
            if (week < 1 || week > 7) {
                System.out.println("有误");
            } else if (week == 1) {
                System.out.println("吃饭");
            } else if (week == 2) {
                System.out.println("睡觉");
            } else if (week == 3) {
                System.out.println("学习");
            } else if (week == 4) {
                System.out.println("运动");
            } else if (week == 5) {
                System.out.println("打飞机");
            } else if (week == 6) {
                System.out.println("约会");
            } else {
                System.out.println("挨打");
            }
        }
    }
}//if语句练习

import java.util.Scanner;
public class demo07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建对象
        while (true){
            System.out.println("输入星期数");
            int week = sc.nextInt();
            switch (week){
                case 1:
                    System.out.println("55");
                    break;
                case 2:
                    System.out.println("44");
                    break;
                case 3:
                    System.out.println("33");
                    break;
                case 4:
                    System.out.println("2");
                    break;
                case 5:
                    System.out.println("22");
                    break;
                case 6:
                    System.out.println("11");
                    break;
            }
        }
    }
}
//switch语句练习

public class demo07 {
    public static void main(String[] args) {
            for(int x=1;x<=100;x++){
                if(x%10 == 7  || x/10%10 == 7 || x%7==0){
                    System.out.println(x+"能被7整除");
                }
            }
    }
}
//逢7过

public class demo07 {
    public static void main(String[] args) {
            int[] arr=new int[20];
            arr[0]=1;
            arr[1]=1;
            for(int x=2;x< arr.length;x++){
                arr[x]=arr[x-2]+arr[x-1];
            }
        System.out.println("第20个月对数是："+arr[19]);
    }
}
//兔子繁衍

public class demo07 {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素的初始化
        int[] arr={11,22,33,44,55};
        int[] arr2={11,22,33,44,55};
        //调用方法，用变量接收
        boolean flag = compare(arr,arr2);
        System.out.println(flag);
    }
    public static boolean compare(int[] arr,int[] arr2){
        if(arr.length != arr2.length){
            return false;
        }

        for (int x=0; x< arr.length;x++){
            if (arr[x] != arr2[x]){
                return false;
            }
        }
        return true;
    }
}
//数组内容是否相同程序 

import java.util.Scanner;//导包
public class demo08 {
    public static void main(String[] args) {
        int[] arr = new int[6];//定义数组，动态初始化

        Scanner sc = new Scanner(System.in);//输入评委分数

        //输入6位的分数
        for (int x = 0; x < arr.length; x++) {
            System.out.println("输入第" +(x+1)+ "分数");
            arr[x] = sc.nextInt();
        }

        printArray(arr);
        int max = getmax(arr);//调用最大数的方法
        int min = getmin(arr);//调用最小数的方法
        int sum = getsum(arr);//调用总和的方法
        int avg = (sum-max-min) / (arr.length- 2);//调用平均值的方法
        System.out.println("最终得分是"+avg);//输出
    }

    //获取总和的方法
    public static int getsum(int[] arr) {
        int sum = 0;
        for (int x = 0; x < arr.length; x++) {
            sum += arr[x];
        }
        return sum;
    }

    //获取最小值的方法
    public static int getmin(int[] arr) {
        int min = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] < min) {
                min = arr[x];
            }
        }
        return min;
    }

    //获取最大值的方法
    public static int getmax(int[] arr) {
        int max = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }

    //遍历数组的方法
    public static void printArray(int[] arr) {
        System.out.print("[");

        for (int x =0;x< arr.length;x++){
            if (x == arr.length -1){
                System.out.print(arr[x]);
            }else{
                System.out.print(arr[x]+",");
            }
        }
        System.out.println("]");
    }
}
//评委打分程序

---

面对对象基础

类和对象

• 类是对象的数据类型
• 类是具有相同属性和行为的一组对象的集合

什么是对象的属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值

什么是对象的行为：对象能够执行的操作

类是对象的抽象

对象是类的实体

---

成员变量与局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量

public class student{//成员变量（大括号内的1）
    String name;
    public class study(){//局部变量（大括号内的）
        int i=0;//局部变量
        System.out.println(".....");
    }
}

区别	成员变量	局部变量
类中位置不同	类中方法外	方法内或方法声明上
内存中位置不同	堆内存	栈内存
生命周期不同	随着对象存在或消失	随着方法调用存在或消失
初始化值不同	有默认的初始值	无默认初始值，必须先定义赋值才能使用

---

封装

private关键字

• 是一个权限修饰符
• 可以修饰成员（成员变量和成员方法）
• 作用是保护成员不被别的类调用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如需要被别的类调用，相应操作如下

• 提供“get变量名()”的方法，用于获取成员变量的值，方法用public修饰
• 提供“set变量名(参数)”的方法，用于设置成员变量的值，方法用public修饰

private int a;


//提供set/get方法
public void setage(int a){
    age a;
}

public int getage(){
    return age;
}

this关键字

• this修饰的变量用于指代成员变量

• 方法的形参如果与成员变量同名，不带this的是形参，而不是成员变量

• 方法的形参没有与成员变量同名，不带this的变量指的是成员变量

  public class student{
      private String name;
      
      private String getname(){
          return name;
      }
      
      private String setname(){
          this.name =name
      }
  }
  

  • 解决局部变量隐藏成员变量
  • this代表所在类的对象引用：方法被哪个对象调用，this就代表哪个对象

this内存原理

封装概述

• 是面向对象三大特征之一（封装，继承，多态）
• 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作

封装原则

• 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getxxx()/setxxx()方法

封装好处

• 通过方法来控制成员变量的操作，提高了代码的安全性
• 把代码用代码进行封装，提高了代码的复用性

---

构造方法

public class StudentDemo{
    public class void main(String[] args){
        Student s1= new Student();//也是一种方法
    }
}

构造方法是一种特殊的方法

作用：创建对象

功能：主要完成对象数据的初始化

public class 类名{
    修饰符 类名（参数）{
    }
}

public class Student{
    private String name;//权限变量
    private int age;
    
    public student(){
        System.out.printin("无参构造方法");
    }
    
    
    
    public void show(){
        System.out.printin(name+","+age);
    }
}

//上段代码测试
Student s = new Student();
s.show();
//输出
/*无参构造方法
null,0*/

方法复习

System.out.printin()//调用系统类的标准输出对象out中的printIn方法
    /*
    System:类
    out:对象
    printIn():方法
    */

public static void main(String[] args) {
    int sum = add(1,2);
    System.out.println(sum);
}
//返回值类型为void
//static为添加类变量

//定义方法
public static int add(int a,int b){
      return a+b;
        }
    /*
    public:修饰符
    static为添加类变量
    int：返回值
    add:方法名字
    */

• 一个方法只完成一个功能，有利于后期的拓展——原子性

最好在main方法里放最简洁的东西

修饰符（可选的） 返回值类型 方法名（参数类型 参数名）{
    ...
        方法体
        ...
        return 返回值
}
//void 空的
//形参：用来定义作用
//实参：实际调用传递的参数

调用方法

int larger = max(30,40);



public class demo10 {
    public static void main(String[] args) {

        int biggest=max(10,20);
        System.out.println(biggest);
    }

    public static int max(int a,int b){

        int result = 0;
        if( a > b){
             result= a;
        }else {
            result=b;
        }
        return result;
    }
}//练习

---

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

优点：易读易看

方法重载的规则：

• 方法名称必须相同（换方法名不叫重载了）
• 参数列表必须不同（个数，类型，参数排列顺序）
• 方法的返回类型可相同可不相同
• 仅仅返回类型不同不足以称为方法的重载

实现理论：

• 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，如果匹配失败，则编译器报错

---

命令行传参

//args.legnth 数组长度

---

可变参数

• 在方法声明后，在指定参数类型后加一个省略号…
• 不确定数量

---

递归

• 递归：自己调用自己，A方法调用A方法
• 利用递归可以用简单的程序解决复杂的问题，通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程中需要的多次重复计算，大大的减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
• 递归结构包括两个部分：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

System.out.println(f(n:5));
    
public static int max(int n){
    if(n ==1){
        return 1;
    }else{
        return n*f(n-1);
    }
    //类似，没写全