JAVA知识点总结第二周

• 目录

选择结构语句：switch

循环语句：for  ,while

跳转控制语句

Java中的方法

方法重载

数组

冒泡排序

面向对象

---

• 选择结构语句：switch

•                     格式：switch(表达式或者某个变量值){

                               case  值1:

                                               语句1;

                                              break;

                               case  值2:

                                                语句2;

                                                break;

                                  ........

                                default:

                                             语句n;

                                             break;

                               }

• 执行流程：switch接收结果，

1. 接收的结果 和case后面的值 1进行比较，成立，执行语句1，break 结束语句；
2. )值1和switch接收的结果不匹配,和值2进行比较,成立,执行语句2, break,结束语句;
3. ........
4. 如果上面case都不匹配,执行default语句,语句n,break ,结束...

• switch语句中的注意事项

1. case语句后面只能常量,不能是变量
2. 在书写switch语句的标准结构,不忘了break,如果语句中忘了书写break,会出现一个现象:case穿透！（  在有的需求里面利用  case穿透 来完成一些需求）
3. 结束条件要么遇见break结束要么程序默认执行到末尾
4. default语句可以在switch语句中的任何位置,不影响语句的执行流程，不管在任何位置,只要case语句都不匹配,执行default;

​
/*
使用switch语句完成 "模拟单项选择题",A,B,C,D
*/
package com.qf.switch_01;

import java.util.Scanner;

//将SwitchTest3代码改进为键盘录入String 类型
public class SwitchTest3__Version2 {

    public static void main(String[] args) {

        //官方正式使用:String  nextLine();录入字符串

        //自己的平时写的时候,也可以用String next():录入字符串

        //提供 单选项选择题内容,模拟
        System.out.println("<<我们结婚吧>> 里面杨桃谁演的?");
        System.out.println("A 高圆圆");
        System.out.println("B 刘亦菲");
        System.out.println("C 张佳宁");
        System.out.println("D 宋佳");

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入您的选择:");
        //官方正式使用:String  nextLine();录入字符串
        String choiceStr = sc.nextLine();

        switch (choiceStr){jdk7以后;switch后面可以使用String 字符串
            case "A":
                System.out.println("恭喜您,答案正确!");
                break ;
            case "B":
                System.out.println("对不起,错误!");
                break ;
            case "C":
                System.out.println("对不起,错误!");
                break ;
            case "D":
                System.out.println("对不起,错误!");
                break ;
            default:
                System.out.println("没有该选项!");
                break ;

        }

    }
}

​

• for循环

       格式:  for(初始化语句;条件表达式;控制体语句或者步长语句){
                     循环体语句;
             }

      执行流程:  初始化语句:给变量赋值   (只执行一次)然后执行条件表达式,看其是否成立,如果成立,执行的是循环体语句------>再次回到控制体语句或者步长语句--->变量自增或者自减
 再次执行条件表达式,是否成立,成立,继续循环体语句---->再次回到控制体语句或者步长语句---->变量自增或者自减...........一直执行到条件表达式不成立,for循环结束。

for(int x = 1 ; x <=10;x++){ //x=1，x<=10, x=2,2<=10,x = 3 , 3<=10,x=10,x<=10,x=11,11<10
            System.out.println("我爱高圆圆") ;//1，2,3.......     10
        }

• for循环的嵌套

• for(初始化语句1;条件表达式1;控制体语句1){
                //循环体就是for循环语句
               for(初始化语句2;条件表达式2;控制体语句2){
                    循环体语句;,,,
                }
            }

• 水仙花

       需求:在控制台输出 水仙花有多少个
       分析:
               1)定义一个统计变量count:从0开始
              2)水仙花:满足3位数,每一个位的数据的立方和相加是这个数据本身
                  100-999之间

public class ForDemo4 {
    public static void main(String[] args) {
        // 1)定义一个统计变量count:从0开始
        int count = 0 ;
        //  2)水仙花:满足3位数,每一个位的数据的立方和相加是这个数据本身
        //*                   100-999之间
        for(int x = 100 ; x <=999; x++){

            // 3)确定每各位的数据本身
            int ge  =  x %10 ;
            int shi = x /10 % 10;
            int bai = x /10/10 %10 ;
            //判断
            if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                //count++
                count ++;
                System.out.println("第"+count+"次,"+"水仙花数是:"+x);
            }
        }
        System.out.println("共有"+count+"个");
    }
}

• while循环

格式：初始化语句;
       while(条件表达式){
         循环体语句 ;
         控制体语句或者步长语句;

执行流程:：首先,先初始化语句,对变量赋值; 执行条件表达式,是否成立;成立,则执行循环体语句,依次控制体语句进行变量控制
  --->再次判断条件表达式是否成立,成立,执行循环体语句--->控制体语句进行变量控制  ...当条件表达式不成立,while循环结束;    注意事项:控制体语句不要忘了,否则死循环;

•  while循环和for循环的区别

共同点:能够描述一种循环思想,可以将重复性冗余代码进行优化,提供程序阅读性

不同点：1.格式不同

               2.场景不同：for循环:明确循环次数   while循环:不明确循环次数

               3.是否节省内存资源:从格式上说 for循环的好处:循环结束之后,变量被释放了
             而while循环,循环结束,依然能够使用这个变量,相对for循环格式来说,比较耗费内存资源

• 死循环的两种格式

      第一个格式:   for(;;){
                 循环体语句;
              }
 
     第二个格式:while(true){   //死循环格式中使用比较多

                   循环体语句;
      }

package com.qf.die_looper_02;

import java.util.Scanner;

/**
 * 需求:猜数字游戏
 *
 * 写代码的过程,经常用alt+enter键:自动提示,补全代码
 *
 *  分析:
 *      1)需要产生一个随机数:java.lang.Math 里面的功能random()产生一个
 *      1-100之间的随机数
 *
 *      //不断的键盘录入
 *      while(true){
 *          2)创建一个键盘录入对象,录入int类型
 *          3)录入的数据要和Math里面产生的1-100之间数据进行对比,
 *       如果大了,提示 "你要猜的数据大了"
 *       如果小了,提示"你要猜的数据小了"
 *        如果一致,提示"恭喜您,猜对了"
 *
 *                  结束死循环,break ;
 *      }
 */
public class DieLooperTest {
    public static void main(String[] args) {

        //1)需要产生一个随机数:java.lang.Math 里面的功能random()产生一个
        //1-100之间的随机数
        int number = (int) (Math.random() *100 +1);
        System.out.println(number) ;


        //定义统计变量
        int count = 0 ;

        //不断的键盘录入
        while(true){
            //只要进一次循环,count++
            count ++;
            //2)创建键盘录入对象
            Scanner sc = new Scanner(System.in) ;

            //3)提示并录入数据
            System.out.println("请您输入要猜的数字:") ;
            int guessNumber = sc.nextInt() ;

            //4)使用guessNumber上面的随机数获取到的number进行对比'
            if(guessNumber>100 || guessNumber< 0){
                System.out.println("你要输入数据不合法,它是在0-100之间");
            }else if(guessNumber> number){
                //如果大了,提示 "你要猜的数据大了"
                System.out.println("你要猜的"+guessNumber+"大了") ;
            }else if(guessNumber <number){
                //如果小了,提示"你要猜的数据小了"
                System.out.println("你要猜的"+guessNumber+"小了") ;
            }else{
                //如果一致,提示"恭喜您,猜对了"
                System.out.println("恭喜您,第"+count+"次猜对了") ;

                //结束死循环
                break ;
            }
        }

    }
}

• 跳转控制语句

break:中断结束(结束循环或者switch)
continue:只是结束当前循环,继续立即进入下次循环(循环语句中使用)
return:结束方法的 (结束有具体返回值的方法）很少单独使用

• Java中的方法

• 在Java中,使用{}代码块,将我们的业务逻辑进行实现,给{}起一个名字,就是方法

• 定义有具体返回值类型的方法的格式

• 固定格式
         public static 返回值类型  方法名(形式参数类型1 参数名1,形式参数类型2 参数名3....){
   //业务逻辑进行实现:举例:完成两个数据比较,获取最大值
                         return 具体的结果;
                  }
• 解释说明
                        public:权限修饰符:公共的公开的/访问权限足够大
                        static:静态修饰符(面向对象中)
                         返回值类型:就是数据类型,现在只学习了基本数据类型,
                         方法名:满足标识符的规范 :方法名和变量名, "小驼峰命名法"
                                         一个单词:字母小写
                                         多个单词:第一个单词字母全部小写,从第二个单词开始,每一个单词首字母大写,其余小写
   
                          形式参数类型1/形式参数类型2:就是数据类型, 现在只学习了基本数据类型,
                          参数名1/参数名2 :就是变量名,起一个名字
   
                         心中两个明确:
                             a)明确方法返回值类型  int
                             b)明确形式参数类型以及参数个数
                              
                                public static 返回值类型  方法名(形式参数类型1 参数名1,形式参数类型2 参数名3....){
   
                                     ///业务逻辑
                                     return 结果;
                                 }
   
                       有具体返回值的方法定义完成之后,需要调用方法
   
                      1)单独调用,不适用于有具体返回值的方法
                      2)输出调用 ,可以,就死了,直接输出,没有意义
                       3)赋值调用 推荐的方式, 因为可以用调用的方法的结果值,继续完成其他业务操作;
                                 接收的结果类型   变量名  = 方法名(实际参数1,实际参数2,...) ;
                       在main方法中,直接写我们定义好的方法名

• package com.qf.function_05;
  
  import java.util.Scanner;
  
  /**
   *  2)键盘录入两个数据,完成两个数据比较,获取最大值 ,使用方法改进
   */
  public class FunctionTest2 {
      public static void main(String[] args) {
  
          //创建键盘录入对象
          Scanner sc = new Scanner(System.in) ;
  
          //提示并录入数据
          System.out.println("请您输入第一个数据:") ;
          int firstNum = sc.nextInt() ;
  
          System.out.println("请您输入第二个数据:") ;
          int secondNum = sc.nextInt() ;
  
          //调用比较两个数据,获取最大值
          int max = getMax(firstNum, secondNum);
          System.out.println("两个数据的最大值是:"+max) ;
      }
  
      /**
       * 定义一个获取两个数据最大值的方法
       * 两个明确
       *      1)明确返回值类型
       *              int
       *      2)明确参数类型以及参数个数
       *              分别都是int,两个
       */
      public static int getMax(int a,int b){ //形式参数
  
          //定义最终结果变量
          int max ;
          //逻辑
          //三元
          //if...else if...else...
         /* if(a>b){
              //将a赋值给max
              max = a ;
          }else if(a==b){
              //a和b的相等
              max = a=b ;
          }else{
              //b大
              max = b ;
          }*/
          if(a>b){
              //将a赋值给max
              max = a ;
          }else{
              //b大
              max = b ;
          }
  
  
          return  max ;
  
      }
  }
  

  定义方法的注意事项

 *  1)方法和方法是平级关系,不能够在一个方法中定义另一个方法,只能在一个方法中调用另一个方法
 *  2)在定义方法的时候,方法中的形式参数必须带上数据类型,因为Java是一个强类型语言;
 *  3)调用方法的时候,实际参数不需要带数据类型;
 *  4)在定义方法的时候,有{的地方不能分号;,有分号;的地方不能{
 *
 *  5)有具体返回值类型的方法,必须携带return,否则报错;

• 没有具体返回值类型的方法定义和调用

当某个业务逻辑里面比如完成的数据的直接输出,展示数据----System.out.println("xxx") ;

或者:业务逻辑中可能数据某个数据在进行排序 数据交换，没有具体的结果是直接输出在控制台上此时java提供了一个关键字 void,代替返回值类型(Java定义方法语法的要求:需求没有具体返回结果,就是用void)

• 固定格式：public static void  方法名(形式参数类型1 参数名称1,形式参数类型2 参数名2,....){

                             }

• 调用格式:

            1)单独调用
             2)输出调用
            3)赋值调用

package com.qf.function_01;

import java.util.Scanner;

/**
 * 键盘录入两个数据,比较两个数据是否相等,需要定义方法来实现,并在主方法中测试
 *
 * 方式1:
 *      可以写一个方法,有返回值结果:true/false  boolean类型
 *
 *  方式2:
 *          可以写一个方法,没有返回值结果,方法里面直接输出
 *                          "两个数据相等" 或者"两个数据不相等"
 */
public class FunctionTest {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入第一个数据:");
        int a  = sc.nextInt() ;

        System.out.println("请输入第二个数据:");
        int b  = sc.nextInt() ;
        //方式1:
        boolean flag = compare(a, b);
        System.out.println(flag);
        System.out.println("------------------------------");
        isEqual(a,b);
    }
    //定义一个方法:没有具体返回值类型
    public static void isEqual(int a,int b){
        if(a==b){
            System.out.println("两个数据相等");
        }else{
            System.out.println("两个数据不相等");
        }
    }
    //定义一个有具体返回值的方法
    public static boolean compare(int a,int b){
        boolean flag = (a==b) ;
        return flag ;
    }
}

• 方法重载:

为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关
                                                      参数列表不同
                                                             1)参数个数不同
                                                             2)参数类型不同
                                                             3)考虑参数类型的顺序

public static double getSUM(int x,double y){
        return  x+y ;
    }
    public static double getSum(double a,int b){
        double result = a +b;
        return  result ;
    }
    public static double getSum(int a,double b){
        double result = a +b;
        return  result ;
    }
    public static double getSum(double a,double b){
        double result = a +b;
        return  result ;
    }

    //定义一个求两个数据之和的方法
    public static int getSum(int a,int b){
        int result = a+b;
        return  result ;
    }
    //定义一个求三个数据之和的方法
   // public static int getSum2(int a,int b,int c){
    public static int getSum(int a,int b,int c){
        int result = a+b+c ;
        return  result ;
    }

    //定义一个求四个数据之和的方法
   // public static int getSum3(int a,int b,int c,int d){
    public static int getSum(int a,int b,int c,int d){
        int result = a + b+ c + d ;
        return  result ;
    }

•  数组

 *      jvm的内存分配
 *          1)栈内存 :存储的就是局部变量
 *          2)堆内存 :以后 new出来的东西都在堆中  (new :创建对象)
 *          3)方法区 :
 *                    xxx.class :字节码文件区域
 *                    后面static区域
 *                    常量池区域.
 *          4)寄存器    5)本地方法区--->     都和cpu和系统相关的

Java中数组就是容器,这个容器  "只能存储同一种类型的元素"
     在数组中定义格式
             动态初始化和静态初始化
             动态初始化:自己定义数组的长度,数组的元素有系统(jvm)默认分配
             格式:
               数据类型[] 数组名称  = new 数据类型[数组长度] ; 推荐第一种
                数据类型 数组名称[]  = new 数据类型[数组长度] ;
               举例
                  int[] arr      = new  int[3] ;
                  int arr[]      = new  int[3] ;

  静态初始化:直接我们自己给定的了元素内容,数组的长度由系统默认分配

静态初始化的简写格式
          数据类型[] 数组对象名 = {元素1,元素2,元素3.....} ; 推荐的写法
            数据类型 数组对象名[] = {元素1,元素2,元素3.....} ;
              int[] arr = {1,2,3} ;
              int arr[] = {1,2,3} ;
在数组中有一个特有的属性:length
               数组名称.length:获取数组长度
               数组中的最大索引值:  数组名称.length-1
java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常 :访问了数组中的不存在的索引就会出现这种问题;
 异常:Exception
         编译时期异常:idea写代码的,编译通过不了,无法运行;  语法有问题;          运行时期异常:    开发者在编写代码的时候,大部分逻辑性不严谨,比如:数组的5个元素,角标最大4,你访问角标5
 

package com.qf.array_03;

/**
 * 数组的应用
 * 已知一个数组:静态初始化了,现在需要把数组的元素遍历出来
 *    遍历:将数组的元素一一打印出来;
 *
 *    int[] arr = {24,87,56,17,13} ;
 *
 *    24
 *    87
 *    56
 *    17
 *    13
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        //有一个数组,静态初始化
        int[] arr = {24,87,56,17,13} ;
        //原始的做法
        //通过  数组名称[角标]访问元素内容,角标从0开始
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);

        System.out.println("---------------------------------") ;
        //上面代码:重复度很大,而且arr不变,变化的内容0,1,2,3,4
        //循环改进
        for(int x=0;x < 5 ;x++ ) { //x代表索引值
            //循环体
            System.out.println(arr[x]);
        }
        System.out.println("---------------------------------") ;
        //继续优化: 上面循环4次,数出来的,而快速得到循环的次数
        //获取数组:数组对象名.length属性
        for(int x=0;x < arr.length ;x++ ) { //x代表索引值
            //循环体
            System.out.println(arr[x]);
        }

        System.out.println("---------------方法优化------------------");


        //调用方法
        printArray(arr);


        System.out.println("---------------方法优化最终版代码------------------") ;

        //需求:现在需要在控制台输出
        //  int[] arr = {24,87,56,17,13} ;
        //[元素1, 元素2, 元素3, ....]
        printArray2(arr);
    }

    //定义一个方法
    public static void printArray2(int[] array){ //形式参数
        //业务逻辑
        //[元素1, 元素2, 元素3, 元素4,  ....]
        System.out.print("[");  //[元素1, 元素2,,,
        //遍历array数组
        for(int x =0 ; x < array.length ; x ++){ //x角标
            //这个角标如果取到了最大角标----  最后一个元素 ,直接输出这个元素内容同时拼接 右]
            if(x== array.length-1){
                System.out.println(array[x]+"]");
                            // 最后一个元素]
            }else{
                //如果不是最后一个角标----  取到的中间的元素,直接输出元素的内容 同时拼接 ", "
                System.out.print(array[x]+", ");
            }


        }

    }

    //定义一个方法:   遍历:将数组的元素一一打印出来;
    /**
     * 两个明确
     *      明确返回值类型 void
     *      明确参数类型 以及参数个数
     *                  引用类型的数组, 1个数组
     */
    public static void printArray(int[] array){//需要传递的数组对象
        for(int x = 0 ; x < array.length ; x ++){
            System.out.println(array[x]);
        }
    }
}

数组中的基本应用

最值问题

package text;

public class text {
    public static void main(String[] args) {
        //创建一个数组静态初始化
        int[] array = {65, 45, 76, 87, 12};
        //定义一个参照物
        int max = array[0];
        for (int x = 1; x < array.length; x++) {
            if (array[x] > max) {
                max = array[x];
            }
        }
        System.out.println("数组中的最大值是：" + max);
        int max2 = getArrayMax(array);
        System.out.println("数组中的最大值是：" + max);
    }

    public static int getArrayMax(int[] arr) {
        int max = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) {
                max = arr[x];

            }
        }
        return max;
    }

}

package text;

public class text1 {
    public static void main(String[] args) {
        int [] arr =  {65, 45,13,78,32};
        int min =  getMin(arr)     ;
        System.out.println("最小值："+min);
    }
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 class ArrayDemo3 {

    public static void main(String[] args) {

        //已知这个数组:
        int[] arr = {69,57,13,24,87} ;

        //调用方法
        int index = getIndex(arr, 13);//找13
        System.out.println("index:"+index);
        System.out.println("----------------------------") ;
        int index2 = getIndex(arr, 133);//找13
        System.out.println("index2:"+index2);

        System.out.println("-----------------------------") ;

        //调用
        int index3 = getIndex2(arr, 255);

        System.out.println("index3:"+index3);
        System.out.println("------------------------------");
        int index4 = getIndex2(arr, 87) ;
        System.out.println("index4:"+index4);

    }

    //方式2:假设思想
    public static int getIndex2(int[] array,int target){
        //1)先定一个变量index:表示索引值
        int index = -1 ; //假设角标找不到

        //2)遍历数组array
        for(int x = 0 ; x <array.length ; x ++){
            //获取到每一个元素array[x]
            //如果 target  == array[x]:找到了,
            if(target==array[x]){
                //将index修改
                index = x ;
                break ;
            }
        }
        return  index ;
    }
    /**
     * 定义一个方法
     *  明确返回值类型: int
     *  明确参数类型以及参数个数
     *          int[],查询的具体的元素   2个参数
     */
    public static int getIndex(int[] array,int target){//array:传递一个数组,target:查询目标元素
        //遍历数组,获取所有元素
        for(int x = 0 ; x < array.length; x++){
            //array[x]:每一个元素就可以获取到
            //判断
            //如果array[x] 和target 相等,就找到了,x返回
            if(target == array[x]){//考虑找到的情况
                return  x ;
            }
        }

        //查询数组:找不到元素,返回负数  -1
        return  -1 ;
    }
}

• 冒泡排序:

         两两比较,将较大的值往后放,第一次比较完毕,最大值出现在最大索引处;
         依次这样比较,可以得到排好序的数组;
  规律
     1)两两比较,将较大的值往后放,
     2)第一次有0个不比
       第二次有1个不比
..........................
       每次比较,就会减少一次比较
    比较的次数:数组长度-1次

     public class BubbleSortDemo {

    public static void main(String[] args) {

        //已知数组:
        int[] arr = {24,69,57,86,13} ;

        //遍历
        System.out.println("排序前:") ;
        printArray(arr);  

        //调用冒泡排序的方法
        bubbleSort(arr);

        //打印
        printArray(arr) ;
    }

    /**
     * 定义方法
     * 两个明确
     *      1)明确返回值类型:void
     *      2)明确参数类型以及参数个数
     *              int[] arr数组
     */
    public static void bubbleSort(int[] arr){
        for(int x = 0 ; x < arr.length-1; x++){//比较的次数
            for(int y = 0; y < arr.length-1-x;y++){
                //前面元素和后面元素比较
                if(arr[y]> arr[y+1]){
                    //互换
                    int temp = arr[y] ;
                    arr[y] = arr[y+1] ;
                    arr[y+1] = temp ;
                }
            }

        }
    }

    //遍历数组,打印元素
    public static void printArray(int[] arr){
        System.out.print("[") ;
        for(int x = 0 ; x < arr.length; x ++){
            if(x==arr.length-1){
                //取到最大索引值
                System.out.println(arr[x]+"]");
            }else{
                //没有取到最大索引值
                System.out.print(arr[x]+", ");
            }
        }
    }
}

• int[] arr = new int[2] ; 完成了哪些事情

1. 在栈内存中 给int [] arr变量开辟栈内存空间
2.  new int [2] ; 在堆内存中申请空间
3. 系统对数组的内容进行默认初始化, int类型元素的默认值0
4. 系统默认初始化完毕,产生一个堆内存空间地址值
5. 将堆内存空间地址值赋值给栈内存变量arr
6. 栈内存变量arr指向堆内存空间地址

• 面向对象

面向对象基于面向过程,面向过程的代表C语言

举例 : 键盘录入三个数据,获取最大值

1)分析 :

2)创建键盘录入

3)写比较的逻辑

4)输出结果. . .

面向过程 : 我们始终是一个执行者 ;

面向对象基于面向过程 :

举例 :现实生活中的例子

洗衣服:

面向过程:

1)脱下脏衣服

2)洗衣盆,泡一泡

3)搓一搓

4)透一透,拧一拧

5)晾衣服..

面向对象:

1)脱下脏衣服

2)放在自动洗衣机里面 一键即可

5)晾衣服...

做饭:

面向过程:

1)去菜市场买菜

2)砍价

3)洗菜

4)摘菜

5)切菜

6)炒菜

7)出锅...

面向对象:

1)外卖或者找一个对象

2)等待出锅

• 面向对象思想特点是什么?

1)更符号生活中的思想行为习惯

2)让复杂的事情简单化

3)从执行者变成了指挥者

• 面向对象的三大特征

封装 继承 多态

基本类型作为形式参数,形式参数改变不影响实际参数;

引用类型作为形式参数,形式参数的改变直接影响实际参数;

• 类

• 类是描述现实世界事物的一组属性和行为的集合;

  类----Java中体现出来,代码描述事物      class 类名{} 类名,见名知意

  类 和事物:一一对应的关系

  学生事物                     定义学生类

  属性 成员变量:类中方法外         行为 成员方法:去掉static

• 长方形事物                定义一个长方形类

  属性:长,宽 width,length           行为:求面积,求周长 getArea() /getZhouChange()

• 描述学生事物
   *          属性:姓名,年龄,性别...
   *          行为:学习,玩游戏,抽烟...
   *
   *          具体的学生:                          ---- 描述具体的学生事物----代码中体现创建这个类对象   :创建具体的对象的格式
   *                                                              类名 对象名  = new 类名();
   *
   *
   *                  张三,20,男                                         对象名.成员变量名 = 赋值;//成员变量赋值
   *                  学习JavaEE                                         对象名.成员方法名();  //调用成员

• public class Student {
  
      //成员变量------学生事物的属性   (类中,方法外)
      String name ; // 学生的姓名
      int age ; // 学生的年龄
      String gender ; //学生的性别
  
  
      //成员方法----学生事物的行为: 行为:学习,玩游戏,抽烟...
      //去掉static
      //学习
      public void study(){
          System.out.println("正在学习JavaEE") ;
      }
  
      //玩游戏:
      public void playGame(String gameName){ //玩什么游戏   "csGo" "吃鸡"
          System.out.println("喜欢玩"+gameName);
      }
      //抽烟
      public void smoke(String somkeBrand){ //抽烟的类型 "华子"...
          System.out.println("喜欢抽"+somkeBrand) ;
      }
  }
  

  public class StudentTest {
      public static void main(String[] args) {
          //测试学生类
          // 高圆圆,25,女 :具体的学生
          //创建学生
          // 类对象
          //类名 对象名  = new 类名();  //按照格式写
          Student s = new Student() ;  // 之前写数据 :int[] arr = new int[2] ; arr----地址值
          System.out.println(s) ; //s的类型 Student类型 :com.qf.oop_02.Student@1540e19d  当前类的地址值 "包名.类名@十进制数据"
          System.out.println(s.name+"---"+s.age+"---"+s.gender);
  
          //对象名.成员变量名 = 赋值;//成员变量赋值
          s.name = "高圆圆" ;
          s.age = 25 ;
          s.gender = "女" ;
  
          System.out.println("这个学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender);
          //访问学生的有哪些行为
  
          // 对象名.成员方法名();  //调用成员方法
          s.study();
          s.playGame("csGo") ;
          s.smoke("云烟");
      }
  }