选择,循环结构；分支语句；数组；面向对象；this关键字.

一.学习选择,分支语句

1.选择结构语句

swit语句

下面展示switch格式 内联代码片。

 switch(表达式){
 case 值1:
         语句1;
         break ;
 case 值2:
        语句2;
         break ;

  ....
  ....

  default:
      语句n+1;
      break ;
 
  }

重点:

面试题:
       switch后面的表达式可以是什么样的数据类型?
       最基本的:byte,short,int,char
       JDK5以后可以是枚举类型
       JDK7以后可以是String类型 (引用类型)

例题:

需求:
      键盘录入一个数据(int),判断当前是星期几
           1,星期一
           2,星期二
           3,星期三
           4,星期四
           5,星期五
           6,星期六
           7,星期日

import  java.util.Scanner  ;
public class SwitchDemo {

    public static void main(String[] args){

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

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

            case 1 :
                System.out.println("星期一");
                break ;
            case 2 :
                System.out.println("星期二");
                break ;
            case 3 :
                System.out.println("星期三");
                break ;
            case 4 :
                System.out.println("星期四");
                break ;
            case 5 :
                System.out.println("星期五");
                break ;
            case 6 :
                System.out.println("星期六");
                break ;
            case 7 :
                System.out.println("星期日");
                break ;
            default:
                System.out.println("您输入的数据不合法");
                break ;

        }


    }
}

2.分支语句

下面展示if语句的几种格式

if语句基本格式

	if(表达式){
        
        语句....
	}
	
	针对某一种情况进行判断

if语句格式二

  	针对两种情况进行判断
  	if(表达式){
        
        语句1;
  	}else{
        语句2;
        
  	}

注意:

If语句格式2和三元运算符的区别?
	if(表达式){
		语句1;
	}else{
		语句2;
	}
	
	(表达式)? 执行true的结果:执行false的结果;
	
	if语句:既可以操作两个数据的数值,也可以操作语句!(使用范围场景更大)
	三元运算符:是针具体数据进行运算
	
	如果能够使用三元运算符实现的,一定能够使用if格式2;
	能够使用if格式2实现的不一定能够使用三元运算符

if语句格式三

  	 针对多种情况进行判断
  	 if(表达式1){
         
         语句1;
  	 }else if(表达式2){
         
         语句2;
  	 }else if(,,,,){
         
         ...
         ...
         ...
  	 }else{
         
         语句n+1;
  	 }

2.循环语句

for循环语句

for循环的格式

       for(初始化语句;条件判断语句;步长语句(控制体语句)){
 
           循环体语句;
       }

流程:

       1)先执行初始化语句对变量进行赋值(只执行一次)
       2)判断条件语句是否成立,如果成立,执行  循环体语句
       3)执行步长语句(++,--)
       4)继续判断条件是否成立,如果还成立, 执行  循环体语句
       5)继续执行步长语句(++,--)
       ...
       ...
       n)当前条件不成立,for循环结束

例题:

需求:
      请求控制台打印10次"helloworld"

public class Demo {

    public static void main(String[] args){
    for(int x = 1 ; x <= 10 ; x ++){
          //x =1 ， x <= 10  第一次
          //x ++，x=2 ， 2<=10   第二次
          //x ++ , x=3 ， 3<=10  第三次
          //x ++,x  =4  ,4<=10  第四次
          //...
          //x++, x = 10 ，10<=10  第十次
          //x ++ ,x =11 , 11<=10 不成立了，for循环结束了
          System.out.println("helloworld");
      }
    }
}

while循环语句

while循环的基本格式:

       while(条件表达式){
           循环体语句;
           控制体/步长语句;
       }

扩展格式:

 *  初始化语句;
 *  while(条件判断语句){
 *      循环体语句;
 *      控制体/步长语句;
 *  }

流程:

 *  初始化语句执行一次
 *  判断条件是否成立,成立,则执行循环体,再依次执行步长语句;
 *  ...
 *  如果不成立,while循环语句结束!

例题:

        输出所有的水仙花数
        int j = 100 ;
        while(j<1000){
            //定义三个变量:ge shi bai
            int ge = j % 10 ;
            int shi = j /10 % 10 ;
            int bai = j /10 /10 % 10 ;

            if(j == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                //输出
                System.out.println(j)  ;
             }

            j ++ ;
        }

输出五次"我爱java"
public class WhileDemo {

    public static void main(String[] args){
        int x = 1 ;
        while(x<=5) {
            System.out.println("我爱java") ;
            x ++ ;//步长语句
        }

在循环的过程中,没有控制变量,导致程序中永远"恒成立"

       for(;;){
           语句;
       }
 
 
       while(true){
 
           语句...
       }

例题:

public class WhileTest2 {
    public static void main(String[] args) {
           for(;;){
            System.out.println("学习java,我很开心") ;
        }

do while循环语句

格式:

   初始化语句;
   do{
       循环体语句;
       步长语句/控制体语句;
   }while(条件表达式) ;

流程:

       初始化语句执行一次,对变量进行赋值
       执行循环体语句,
       执行步长语句(++或者--)
       判断while后的条件是否成立,成立,继续执行循环体语句...
       不成立,语句结束!

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

        //控制台输出5次"helloworld"
       // int i = 1 ;
        int i = 6 ;
        do{
            System.out.println("helloworld") ;
            i++;
        }while(i<=5) ;
    }
}

注意:

do-while循环和for循环以及while循环的最大的区别就是:循环体至少执行一次!

二.学习循环语句的嵌套

for语句嵌套

  for循环嵌套
       for(初始化语句;条件表达式;步长语句){
 
           //内层循环是外层循环的循环体语句
           for(初始化语句;条件表达式;步长语句){
                   循环体语句;
 
           }
       }

例题:

  需求:
  控制台输出*形(4行5列的*)

public class ForForDemo {
    public static void main(String[] args){
            for(int x = 0; x < 4 ; x ++ ){//x =0 ,1,2,3  //控制行数

            for(int y = 0 ; y < 5; y++){//y =0,1,2,3,4 //控制列数
                System.out.print("*") ;
            }
            System.out.println() ;
        }
    }
}

 for (循环）“百钱买百鸡”是我国古代的著名数学题。题目这样描述：3 文
  钱可以买1只公鸡，2 文钱可以买一只母鸡，1 文钱可以买3 只小鸡。用100 文
  钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？
  
  public class for_test {
    public static void main(String[] args){

        //定义三个变量:分别代表:公鸡,母鸡,小鸡
        int x ,y,z ;

        //公鸡的范围
        for( x = 0 ; x <=33 ; x ++){
            //母鸡的范围
            for(y = 0 ; y <= 50 ; y ++){

                //小鸡的数量:
                z = 100 - x - y ;
                //满足的条件
                if(z % 3 == 0){
                    //并且满足条件:总数量加起来100只
                    if((3*x + 2*y+z/3)==100){
                        //公鸡,母鸡,小鸡
                        System.out.println("公鸡有"+x+"只"+"\t"+"母鸡有"+y+"只"+"\t"+"小鸡有"+z+"只") ;
                    }
                }
            }

        }
    }
}

三.学习数组的使用

什么是数组

    容器:就是能够存储很多数据---先讲"数组"
 
    数组是一个容器,能够存储同一种类型元素的容器!

格式:

    数据类型[] 变量名称 ;
    
    数据类型 变量名称[] ;

举例:

    int[] arr ; 定义了一个int数组的arr变量  (推荐这个格式)
    int arr[] ; 定义一个int类型的arr数组

数组的如何初始化

    两种初始化:
                第一种初始化: 动态初始化
                第二种初始化:静态初始化

    动态初始化:  给定数组的长度,元素由系统默认初始化!
                格式:
                数据类型[] 数组名称  = new 数据类型[长度] ; 
                数据类型 数组名称[] = new 数据类型[长度] ;
    静态标准格式:
       数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3.....} ;
       数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
       简写格式
       数据类型[] 数组名称 = {元素1,元素2,元素3.....} ; (推荐)
       数据类型 数组名称[]  = {元素1,元素2,元素3.....} ;

注意事项:

 //int[] arr = new int[5]{11,22,33,44,55} ;
 //错误的:数组初始化只能有一种:不能既动态初始化,又静态初始化

遍历数组

查找方法:

  基本元素查找法:(从头查到尾)
 
  查询一个数组中的某个元素第一次在数组中出现的索引值(不考虑重复元素)

例题:

public class ArrayTest4 {
    public static int getIndex(int[] arr,int key){  
        //如果传递了数组中没有的元素  200
        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            //判断如果key就是要找的元素
            if(key == arr[x]){
                //获取这个角标
                return x ;
            }
        }

        //java中:查询元素,如果找不到,返回结果负数 ()
        return -1 ;
    }
}

求数组中最大/最小值

思路:

假设法:
定义一个最大值max
当前数组中第一个元素arr[0]是最大值
从角标1开始,遍历后面的元素
判断:如果后面的元素都比max大的话,当前arr[0]不是最大值
只需要改变max的值

例题:

public class ArrayTest2 {
    public static int getMin(int[] arr){
        //定义参照物
        int min = arr[0] ;
        //从角标1开始遍历元素
        for(int x = 1 ; x < arr.length ; x ++){
            //判断后面的元素依次和max进行比较
            if(arr[x] < min){
                min = arr[x] ;
            }
        }
        return min ;
    }
}

将数组进行逆序

思路:

   分析:
       1)定义功能----将原数组,先进行遍历  (逆序之前)
           [12, 87 ,69, 24, 65]
       2)逆序(方法)
               将arr[0]元素和arr[arr.length-1]的进行互换
               将arr[1]元素和arr[arr.length-1-1]的元素进行互换
               ...
               保证当前元素的范围:角标0开始  数组长度/2

       3)再次调用遍历数组的功能

例题:

public static void reverse(int[] arr){//数组
// 保证当前元素的范围:角标0开始  数组长度/2
        for(int x = 0 ; x < arr.length/2 ;x ++){
            //定义中间变量
            int temp = arr[x] ;
            arr[x] = arr[arr.length-1-x] ;
            arr[arr.length-1-x] = temp ;
        }

    }
//遍历
var foo = 'bar';    //遍历的功能
    public static void printArray(int[] arr){
        System.out.print("[") ;
        //遍历元素
        for(int x = 0 ; x < arr.length ; x ++){//x表示角标值0,
            //判断:x是否为最大索引值:
            //如果是最大索引值,取到最后一个元素了arr[arr.lenght-1]
            if(x == arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                //中间的元素
                System.out.print(arr[x]+", ") ;
            }

        }
    }
}

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

        int [] aa = {1,2,3,4,5,6,7,8,9};
        shunxu(aa);
        nixu(aa);
        shunxu(aa);
    }

    //输出
    public static void shunxu (int []aa){

        System.out.print("[");
        for(int x = 0 ; x < aa.length ; x ++){

            if (aa.length-1 == x){
                System.out.println(aa[x]+"]");
            }else{
                System.out.print(aa[x] + ",  ");
            }
        }
    }

    //顺序颠倒
    public static void nixu ( int []aa){

        for (int y = 0 ; y < aa.length/2 ; y ++ ){

            int temp = aa[y];
            aa[y] = aa[aa.length-1 - y];
            aa[aa.length-1 - y] = temp;
        }
    }
 }

查找元素

思路:

  基本元素查找法:(从头查到尾)
 
  查询一个数组中的某个元素第一次在数组中出现的索引值(不考虑重复元素)

public class ArrayTest4 {

    public static void main(String[] args){

        //定义一个数组,静态初始化
        int[] arr = {13,67,89,100,230,97} ;

        //调用:获取角标值的方法
        //int index = getIndex(arr, 67);
        // System.out.println("index:"+index) ;
        int index = getIndex(arr, 200);
        System.out.println("index:"+index) ;
        System.out.println("-----------------------");
        int index2 = getIndex2(arr,97) ;
        int index3 = getIndex2(arr,500) ;
        System.out.println("index2:"+index2);
        System.out.println("index3:"+index3);
    }

    //方式2:假设思想
    public static int getIndex2(int[] arr,int key){
        //先定义一个角标值:index
        int index = -1 ; //找不到
        //遍历数组
        for(int x = 0 ; x < arr.length ;x ++){
            //如果当前key就是arr[x]
            if(key == arr[x]){
                //改变index的值
                index = x ;
                break;  //结束循环
            }
        }
        return index ;
    }


    /**
     * 定义获取数组中的元素角标值的方法
     * 两个明确:
     *  1)明确返回值类型: int
     *  2)明确参数类型以及参数个数
     *      int类型数组以及查找的元素,2个
     */
    public static int getIndex(int[] arr,int key){   
    //如果传递了数组中没有的元素  200
        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            //判断如果key就是要找的元素
            if(key == arr[x]){
                //获取这个角标
                return x ;
            }
        }

        //java中:查询元素,如果找不到,返回结果负数 ()
        return -1 ;
    }
}

例题:

package com.homework_;

//9.int[] arr = {10,55,30,24,17} ;
//查询30这个元素第一次在数组中出现的索引,查询元素使用功能完成!
public class chaxun_ {
    //创建数组
    public static void main (String [] args){

        int [] aa = {10,55,30,24,17} ;
        int i = num( aa , 24);
        System.out.println("num:" + i);
    }

    public  static int num( int []aa,int key){

        int i = -1 ;//未找到
        for ( int y = 0 ; y < aa.length ; y ++ ){

            if ( key ==aa[y]){

                i = y ;
                break;
            }
        }
        return  i ;
    }
}

四.学习面向对象

什么是类

类-----  描述 "现实世界的事物"

			--- 			事物 (学生/老师/军人/工人....)
     							属性:姓名,年龄,身高,性别....
								行为:学生--学习,老师---讲课
								     军人--保家卫国...
								     
以Java语言的程序体现出来!
类
	成员变量:
	成员方法

基本数据类型作为形式参数传递有什么特点:

基本类型作为形式参数传递,形式参数的改变不会影响实际参数,
实际参数是什么,它的值还是那个原来的数据!

引用数据类型作为形式参数传递有什么特点: (后期研究的肯定是引用类型)
引用类型(数组,类,接口) 作为形式参数传递,形式参数的改变会直接影响实际参数!

示例:

public class ArgsDemo_ {

    public static void main(String[] args){

        //定义两个变量
        int a = 10 ;
        int b = 20 ;
        System.out.println("a:"+a) ;
        System.out.println("b:"+b) ;
        System.out.println("-----------------") ;
        //调用change方法
        change(a,b) ;
        System.out.println("a:"+a) ;
        System.out.println("b:"+b) ;
        System.out.println("-----------------") ;


        //创建一个数组
        int[] arr = {1,2,3,4,5} ;
         //int[] arr = new int[]{1,2,3,4,5} ;
        System.out.println(arr);
        System.out.println(arr[1]) ; //2
        change(arr) ;
        System.out.println(arr[1]) ;
    }

    //重载的change方法
    public static void change(int[] arr){ //地址值
        //遍历数组
        for(int x =0 ; x < arr.length ; x ++){
            if(arr[x] % 2 == 0){
                arr[x] *= 2;
            }

        }
    }


    //change方法传递的是两个基本类型
    public static void change(int a,int b){ //形式参数

        System.out.println("a:"+a);
        System.out.println("b:"+b) ;
        System.out.println("===================================") ;
        a = b ;
        b = a+ b ;
        System.out.println("a:"+a);
        System.out.println("b:"+b) ;
    }

}

数组高级排序之冒泡

思路:

           两两比较,第一次比较完毕,最大值出现在最大索引处
           依次这样比较
 
           规律:
               两两比较,第一次比较完毕,最大值出现了
               每次比较完毕,下一次减少比较
                 第一次:有0个不比
                 第二次,有1个不比
                 第三次,有2个不比
                 第三次,有3个不比
 
                 最终比较的次数:数组长度-1次

示例:

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

        //已知一个数组
        int[] arr = {24,69,87,57,13} ; //无序的数组
        System.out.println("排序在之前:");
        printArray(arr);

        /*//第一次比较
        //arr.length-1:为了防止角标越界
        //arr.length-0:第一次比较:0个不比 (为了减伤比较的次数)
        for(int x = 0 ; x < arr.length-1-0; x ++){
            //判断:如果前面的元素比后面元素大,将大的元素往后方法
            //交互元素----采用中间变量的方式
            if(arr[x] > arr[x+1]){
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1]  = temp ;
            }
        }
        System.out.println("-----------------------------");

        System.out.println("第一次比较完毕:");
        printArray(arr);
        System.out.println("-----------------------------");
        //第二次比较
        //arr.length-1:为了防止角标越界
        //arr.length-1-1:第二次比较:有1不比
        for(int x = 0 ; x < arr.length-1-1;x++){
           //判断:如果前面的元素比后面元素大,将大的元素往后方法
            //交互元素----采用中间变量的方式
            if(arr[x] > arr[x+1]){
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1] =temp ;
            }
        }
        System.out.println("第二次比较完毕:");
        printArray(arr);

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

        //第三次比较
        //arr.length-1:为了防止角标越界
        //arr.length-1-2:第二次比较:有1不比
        for(int x = 0 ; x < arr.length-1-2;x++){
            //判断:如果前面的元素比后面元素大,将大的元素往后方法
            //交互元素----采用中间变量的方式
            if(arr[x] > arr[x+1]){
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1] =temp ;
            }
        }
        System.out.println("第三次比较完毕:");
        printArray(arr);

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

        //第四次比较
        //arr.length-1:为了防止角标越界
        //arr.length-1-3:第二次比较:有1不比
        for(int x = 0 ; x < arr.length-1-3;x++){
            //判断:如果前面的元素比后面元素大,将大的元素往后方法
            //交互元素----采用中间变量的方式
            if(arr[x] > arr[x+1]){
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1] =temp ;
            }
        }
        System.out.println("第四次比较完毕:");
        printArray(arr);*/


        //上面代码重复比较高的,使用循环思想改进:
        //总共循环了四次
        for(int x = 0 ; x < 4 ; x ++){//0,1,2,3  :循环的次数
            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 ;
                }
            }
        }

        //输出
        System.out.println("排序完毕后:");
        //将数组遍历
        printArray(arr);


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

        //上面的代码:4: 循环的次数-----写死了
        //冒泡排序比较的次数:就是数组长度-1次

        for(int x = 0 ; x < arr.length-1 ; x ++){
        //0,1,2,3  :循环的次数
            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 ;
                }
            }
        }

        //输出
        System.out.println("排序完毕后:");
        //将数组遍历
        printArray(arr);

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


        //调用方法来完成:排序
        bubbleSort(arr);

        //遍历
        printArray(arr);


    }

    /**
     *  最终版代码:
     * 定义一个方法:专门来对数组进行冒泡排序的
     * 两个明确
     *  1)明确返回值类型: void (没有具体返回值类型)
     *  2)明确参数类型以及参数个数
     *      int[]  ,1个参数
     */
    public static void bubbleSort(int[] arr){
        for(int x = 0 ; x < arr.length-1 ; x ++){
              //0,1,2,3  :循环的次数
            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]+", ") ;
            }
        }
    }
}

例题:

package HomeWork_;

//3.自定义一个数组,进行冒泡排序,并按照[元素1, 元素2, 元素3, 元素4]输出
public class bubble_ {
    //定义数组
    public static void main (String []args){
        int [] aa = {9,6,7,4,2};

        sort(aa);
        num(aa);
    }
    //调整顺序
    public static void sort (int [] aa){
        //调整次数
        for (int x = 0 ; x < aa.length-1 ; x ++ ){
            //每两位调整
            for (int y = 0 ; y < aa.length -1-x ; y ++){

                if (aa[y] > aa[y+1]){
                    int temp = aa[y];
                    aa[y] = aa[y+1];
                    aa[y+1] = temp;
                }
            }
        }

    }
    //遍历
    public static void num( int [] aa){

        System.out.print("[");
        for (int a = 0 ; a < aa.length ; a ++){

            if ( a == aa.length-1){

                System.out.println(aa[a] + "]");
            }else {

                System.out.print(aa[a] + ",  ");
            }
        }
    }
}

例题:

package HomeWork_;
//4.学生有姓名,年龄,性别属性,行为有学习,
//睡觉以及玩游戏的行为,请使用面向对象方式书写学生类并且进
//创建类
class peo{
    //定义成员变量
    int age ;
    int high;
    String name;
    String sex;
    //定义方法
    public void study(String x ){System.out.println("学习"+x);}

    public void sleep(String y ){System.out.println("睡觉"+y);}

    public String game (){return "游戏";}
}

//测试类
public class Student_ {
    public static void main (String [] args){
    //创建类对象
    peo a = new peo();
    //成员变量赋值
    a.age = 19;
    a.high  = 188;
    a.name = "哪吒";
    a.sex = "男";

    //测试类方法
    a.sleep("JAVA");
    a.study("天亮") ;
    String game = a.game();
    System.out.println("游戏");
    }
}

匿名对象

概念:

 匿名对象:顾名知意:    没有名字的对象

 类名 对象名 = new 类型() ;  有名字的对象

匿名对象的格式:

 new  类名() ;
 new 类名().成员方法名() ; 访问当前类中的成员方法

       1)匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!
           应用场景:都是在移动端使用居多---Android :基于Java 
          (大部分都是使用匿名对象,节省内存)
       2)开发中,匿名对象使用一次即可,不要使用多次!
          (使用完毕,就立即被回收)

       3)匿名对象可以作为参数传递

示例:

class Student{
    public void study(){
        System.out.println("好好学习,天天向上!") ;
    }
}

//定义一个类StudentDemo
class StudentDemo{
    public void method(Student student){
    //形式参数一个引用类型: 
    //Student ----实际参数传递:Student s= new       Student() l
        student.study();
    }
}


/**
 *测试类
 */
public class NoNameDemo {

    public static void main(String[] args){

        //Java中创建类的对象的标准格式
        //类名 对象名  = new 类名() ;
        Student s = new Student() ;
        s.study();
        System.out.println("----------------------");



        //  new  类名() ; 对象
        new Student().study();

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

        //需求:访问StudentDemo类中method方法
        //创建StudentDemo类对象
        StudentDemo sd = new StudentDemo() ;
        //调用method方法
        //创建具体学生对象
        Student student = new Student() ;
        sd.method(student);

        System.out.println("----------------------");
        //匿名对象作为参数传递
        //需求:访问StudentDemo类中method方法
        //创建StudentDemo类对象
        StudentDemo sd2 = new StudentDemo() ;
        sd2.method(new Student());

        System.out.println("==========================");
//需求:访问StudentDemo类中method方法
        //使用匿名对象优化
        //链式编程 :开发中使用不多(自己玩可以使用)
        new StudentDemo().method(new Student());



    }
}

成员变量私有化

概念:

Java提供一个关键字:private  封装
将一个类中的成员变量(属性)私有化,对外提供公共的访问方法,
来保证类的安全性!
目的:为了外界不能够直接访问
private(私有)关键字:
 被private修饰的成员变量,成员方法只能在本类中访问,外界类不能访问

示例:

//定义一个类 Code
class Code{

    //private可以修饰成员变量,修饰成员方法

    //定义两个成员变量
    public int num = 10 ;
    private int num2 = 20 ;

    //定义公共的成员方法
    public void method(){
        System.out.println("method code...");
        System.out.println(num);
        System.out.println(num2);
    }
    //私有的成员方法
    private void function(){
        System.out.println("function code...");
    }

    //定义公共方法
    public void show(){
        function();
    }


}
//测试类
public class PrivateDemo {

    public static void main(String[] args){
        //需求:访问Code类中num和num2变量
        //创建Code类对象
        Code c = new Code();
        System.out.println(c.num);
        System.out.println("-----------------------------");
       // System.out.println(c.num2); //不能外界类访问
        //外界类可以通过公共的方法间接访问私有的成员变量
        c.method();

       // c.function() ;//function()方法是私有的,只能在本类中访问
        System.out.println("------------------------------");
        //可以间接的访问私有的方法----通过公共的访问
        c.show();


    }
}

示例:

class Student{
    //成员变量
    String name ;//姓名
   //private int age ; //年龄 加入private修饰
    int age ;//年龄
   String sex ; //性别

    //定义一个方法:专门判断年龄的值
    public void setAge(int num){
        if(num<0|| num <150){
            System.out.println("当前年龄是一个非法数据");
        }else{
            //正常数据
            //赋值
            age = num ;
        }
    }

    //成员方法
    public void study(){
        System.out.println("学习JavaSE...");
    }

    //展示信息
    public void show(){
        System.out.println("学生的姓名是:"+name+",年龄是:"+age+",性别是:"+sex);
    }



}
//测试类
public class StudentTest {
    public static void main(String[] args){
        //创建一个学生对象
        Student s = new Student() ;
        //给学生对象s进行成员变量赋值
        s.name = "高圆圆";
        s.age = 41 ;
        s.sex = "女" ;

        s.show();
        s.study();
        System.out.println("------------------------------");
       /* //创建第二个学生对象s2
        Student s2 = new Student();
        //给成员变量赋值
        s2.name = "赵又廷" ;
        s2.age = -39 ;
        s2.sex ="男" ;
        s2.show();
        s2.study();*/

       //改进代码之后:
        Student s2 = new Student();
        s2.name ="赵又廷" ;
       // s2.setAge(-41); //年龄赋值: 通过setAge()方法赋值
        s2.age = -41 ;
        s2.sex ="男" ;
        s2.show();

    }
}

五.接触this关键字

什么是this关键字

  学生类
   n,a,s----分别代表:姓名,年龄和性别
       定义变量:标识符的规则:---见名知意
      改造---将n--name
             a  -- age
             s  --sex
 
  发现:没有办法区分:哪一个name,age,sex是局部变量还是成员变量
 
   Java提供了一个关键字-----this    (解决----局部变量将成员变量隐藏了)
 
       this:代表当前这个类的对象的地址值引用

public class Student {

    //属性私有化
    private String name ;//姓名
    private int age ;//年龄
    private String sex ;//性别

    //提供对外的公共的访问方法
//    public void setName(String n){
    public void setName(String name){
       this.name = name ;
    }

    public String getName(){
//        return this.name ;
        return name ; //return 里面隐藏了this关键字(一般不写)
    }

//    public void setAge(int a){
    public void setAge(int age){
       this.age = age ;
    }
    public int getAge(){
        return age ;
    }

//    public void setSex(String s){
    public void setSex(String sex){
        this.sex  = sex ;
    }
    public String getSex(){
        return sex;
    }

    //成员方法
    public void study(){
        System.out.println("学习JavaEE...");
    }
    //爱好
    public void hobit(){
        System.out.println("爱生活,爱Java...");
    }
}