JAVA学习---从头开始week02

循环语句

for循环:

使用最多,求和思想,统计思想
格式:

for(初始化语句;条件表达式;控制体语句){
           循环体语句;
           }

eg:

for(int x=1;x<=10;x++){
       System.out.println("你在哪,我想你!")
       }

执行流程:1)初始化语句:给变量赋值
2)执行条件表达式,看其是否成立.成立执行循环体语句------再次执行控制体语句--------变量自增或自减
3)再次执行条件表达式,成立执行循环体语句------再次回来控制体语句------变量自增或自减
4)执行到条件表达式不成立,for循环语句
典型例题:
在控制台输出所有的水仙花数.
注:水仙花数指的是三位数,且这个三位数每一个位上的立方相加就是这个数本身.
举例:153 = 1 * 1 * 1 + 555 + 333

              153  % 10  = 3 ;---确定个位的数据
              153 / 10  % 10  = 5 --- 确定十位的数据
             153 /10 /10 %10 = 1 --- 确定百位上的数据

分析

•        1)三位数,明确了范围 100-999---使用for循环       x
         2) 确定每各位的数据本身的值:
                     定义三个变量,分别代表个位,十位,百位数据本身
                      int ge = 当前这个数据 % 10 ;
                      int shi = 当前这个数据 /10 %10 ;
                      int bai = 当前这个数据 /10/10 % 10 ;
         3)for循环中加入逻辑判断
                      如果当前x  == (ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai),
                      满足条件,直接输出x
  

代码展示:

package com.qf.for_02;
public class shuiXianHua {
    public static void main(String[] args) {
        System.out.println("水仙花数是:") ;

         // 1)三位数,明确了范围 100-999---使用for循环      
        for (int x = 100; x < 1000; x++) {
            //x:100-999的数据
            //确定每各位的数据本身的值:
            // 定义三个变量,分别代表个位,十位,百位数据本身
            int ge = x %10 ; //x=153
            int shi = x /10 %10 ;
            int bai = x /10 /10 % 10;

            //如果当前x  == (ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai),满足条件,直接输出x
            if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                System.out.println(x) ;
            }
        }
    }
}

for循环的综合运用(for循环嵌套)
格式: for(初始化语句1;条件中表达式1;控制体语句1)
{ //外层循环
// 循环体语句又是一个for循环
for(初始化语句2;条件表达式2;控制体语句2) {
循环体语句…
}
}
eg:

for(int x = 0 ; x < 5 ; x ++){//外层循环 x=0,1,2,3,4  5行
            for(int y = 0 ; y < 5 ; y ++){//内层循环: y=0,1,2,3,4  5列
                System.out.print("*");
            }
            System.out.println();

例题:打印九九乘法表:

package com.qf.forfor_03;
public class ForForDemo2 {
    public static void main(String[] args) {
 for(int x = 1 ; x <= 9 ; x++){ //9行
         for(int y = 1 ; y<=x ; y ++){//列数随着x的变化而变化
//Java中 转移字符 "\t"---->制表符 相当于tab 缩进空格
         System.out.print(x +"*"+y+"=(y*x)+"\t");
                //1*1=1
                //2*1=2  2*2=4
                //3*1=3  3*2=6  3*3=9
                //
           }
            System.out.println();//换行

        }

while循环

格式:
初始化语句
while(条件表达式){
循环体语句;
控制体语句
}
执行流程: 1)先初始化语句对变量进行赋值
2)执行条件表达式,成立执行循环体语句之后执行控制体语句对变量进行控制
3)再次判断条件表达式是否成立,成立执行循环体语句------执行控制体语句进行变量控制
4)当条件表达式不成立,while循环结束
注:控制体语句不能忘记,否则进入死循环
eg: `

int a=1;
           while(a<=5){
           System.out.println("还好吗")
           a++
           } 

例题:求1-100之间的和
求1-100之间的偶数和

package com.qr.while
public class WhileTest {
    public static void main(String[] args) {
    int sum =0;
    int a = 1;
    while(a<=100)
    sum +=a;
    a++;
    }
    System.out.println("1-100之间的和为:"+sum);
    //输出语句中sum前的+为拼接符号,不是加号
    //求偶数和
    int result = 0 ;
        //初始化语句
        int num = 1 ;
        while(num<=100) {
            //循环体
            if(num %2 ==0){//能被2整除说明是偶数
                result += num ;
            }
            num ++;
        }
        System.out.println("1-100之间的偶数是:"+result);

for循环和while循环的区别:

共同点:都是能够体现循环思想,解决代码冗余问题
不同点:
1)格式不同
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
2)使用场景不同
for循环(普通for循环),明确循环次数优先采用for (实际开发中for使用很频繁:遍历数组,获取数组的元素)
后期学习特殊for循环(增强for循环—>集合 中使用频繁的)
while循环: 不明确循环次数使用while循环
3)从内存角度是否节省内存
for循环的这种格式,比较节省内存资源,当for循环结束,里面的变量被释放了,
这个变量作用域就在 for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
while循环,相对for循环,比较消耗内存,当while循环,依然能够访问变量
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)…
如果上面case都不匹配,执行default语句,语句n,break ,结束.
例题:
/键盘录入一个值,判断星期
//* 1,星期一
//* 2,星期二
//* 3,星期三,
//* 4,星期四
//* 5,星期五
//* 6,星期六
//* 7,星期日

package com.qf.switch_01;

import java.util.Scanner;
public class SwitchDemo2 {

    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入一个星期(1-7的数据): ") ;
        int week = sc.nextInt() ;

        int b = 2 ;


        switch (week){
            default:
                System.out.println("非法数据");
                //break ; //如果default在语句中,break不能省略,否则case穿透
            case 1:
                System.out.println("星期一") ;
                break ;
            //case b: //需要的是常量表达式,不能是变量
            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 ;  //可以省略,但是不建议;

        }
    }
}

注意事项(考点):
1)关于switch中的case语句后面只能常量,不能是变量 (体现Java是一种强类型语言)
----前端的javascript(弱类型语言):它里面的swtich的case是可以是变量,可以是个常量
2)在书写switch语句的标准结构,不忘了break,如果语句中忘了书写break,会出现一个现象:case穿透! 在有的需求里面利用 case穿透 来完成一些需求;
3)关于switch语句的结束条件
a)要么遇见break结束
b)程序默认执行到末尾
4)关于default语句可以在switch语句中的任何位置,不影响语句的执行流程;
不管在任何位置,只要case语句都不匹配,执行default;
如果default语句在语句中,break不要省略
如果default语句的末尾,break可以省略;0
.switch语句后面的表达式可以是什
么数据类型?
可以跟的基本数据类型 byte,short ,int ,char
jdk5以后,可以枚举类型
jdk7以后,可以String类型.
死循环的两种格式

        for(;;){
         循环体语句;
         }

        while(true){ //死循环格式中使用比较多
        循环体语句;
          }

break和contine的笔试题
for(int x= 1 ; x <=10;x++){
if(x %3==0){
//补全代码
}
System.out.println(“你好”);
}
1)需要在控制台输出 2次"你好" break
2)需要在控制台输出7次"你好" continue
3)需要在控制台输出13次"你好"
System.out.println(“你好”);

Java中的方法

方法:给某段代码,使用{}包裹起来,给这个{}起一个名字,方法名,就可以有相同业务逻辑代码,直接使用方法名调用,提高代码的复用性;

有具体返回值方法的定义格式
固定写法:
public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参
数名2,…){
//完成功能业务逻辑…
return 具体结果;
}
有具体返回值类型的方法的调用格式
在main方法中赋值调用
接收的结果类型 变量名 = 方法名(实际参数1,实际参数2,…) ;
实际参数:直接赋值或者main中键盘录入.

需求:
键盘录入两个数据,完成两个数据比较,获取最大值 ,使用方法改进
分析:

•          1)定义一个方法:求和的方法,  两个数据
                  心中两个明确:
                 a)明确方法返回值类型  int
                 b)明确形式参数类型以及参数个数
                          两个参数:都是int
  

•   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)在定义方法的时候,有{的地方不能分号;,有分号;的地方不能{

无具体返回值类型的方法定义和调用

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

• 业务逻辑中可能数据某个数据在进行排序 数据交换

• 这种方法在定义的时候,

• 还有是遵循有具体返回值类型的方法定义格式:
  *没有没有具体的结果是直接输出在控制台上,

• 此时java提供了一个关键字 void,代替返回值类型(Java定义方法语法的要求:需求没有具体返回结果,就是用void)
  格式:
  public static void 方法名(形式参数类型1 参数名称1,
  形式参数类型2 参数名2,…){
  }
  调用格式
  单独调用
  举例
  public static void getMax(int a,int b){
  //完成逻辑判断
  //举例
  if(a>b){
  System.out.println(a+“是最大值”);
  }else{
  System.out.println(b+“是最大值”);
  例题:
  键盘录入三个数据,比较三个数据最大值

package com.qf.function_01;

import java.util.Scanner;

public class FunctionTest2 {

    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() ;

        System.out.println("请输入第三个数据:");
        int c = sc.nextInt() ;
        //:有返回结果的方法调用
        int max = getMax(a,b,c) ;
        System.out.println("三个 数据的最大值是:"+max);

        System.out.println("----------------调用没有返回值类型的方法--------------------") ;
        getMax2(a,b,c);
    }
    //无返回值:直接在方法中输出结果
    public static void getMax2(int a,int b,int c){
        if(a>b){
            if(a>c){
                System.out.println(a+"是最大值") ;
            }else{
                System.out.println(c+"是最大值") ;
            }
        }else{
            if(b>c){
                System.out.println(b+"是最大值");
            }else{
                System.out.println(c+"是最大值");
            }
        }
    }

    //有返回值
    public static int getMax(int a,int b, int c){
        int max ;  //声明这个变量max
        if(a>b){
            if(a>c){
                max = a ;
            }else{
                max = c ;
            }
        }else{
            if(b>c){
                max = b ;
            }else{
                max = c ;
            }
        }
        return  max ;
    }

方法重载

什么是就是方法重载?(overload)
方法重载:为了某个功能扩展性,多个方法方法名完全相同,参数列表不同,与返回值无关

• 参数列表不同
  1)参数个数不同
  2)参数类型不同
  3)参数类型的顺序

package com.qf.overload_02;

import java.util.Scanner;

/**
 * 需求:比较两个数据是否相等
 *
 * 满足2个类型,
 *      两个int类型进行比较
 *      两个double进行比较
 */
public class OverLoadTest {
    public static void main(String[] args) {

        //定义两个变量
        int a = 10 ;
        int b = 20 ;

        double x = 12.56 ;
        double y = 12.56 ;
        //重载方法
        boolean flag = compare(a, b);
        boolean flag2 = compare(x, y);
        System.out.println(flag) ;
        System.out.println(flag2) ;
    }
    //两个int类型进行比较
    public static boolean compare(int a,int b){
        return  a==b ;
    }
    public static boolean compare(double a,double b){
        return  a==b;
    }
}

数组

Java中数组就是容器,这个容器 “只能存储同一种类型的元素”

• 在数组中定义格式

• 动态初始化和静态初始化

• 动态初始化:自己定义数组的长度,数组的元素有系统(jvm)默认分配
  *格式:
  数据类型[] 数组名称 = new 数据类型[数组长度] ;
  数据类型 数组名称[] = new 数据类型[数组长度] ;
  eg: int[] arr = new int[3] ;
  * int arr[] = new int[3] ;
  静态初始化:直接我们自己给定的了元素内容,数组的长度由系统默认分配
  *原生的格式写法:

• 数据类型[] 数组对象名 = new 数据类型[]{元素1,元素2,元素3…} ;

• 数据类型 数组对象名[] = new 数据类型[]{元素1,元素2,元素3…} ;

• 举例

• int[] arr = new int[]{1,2,3} ;

• int arr[] = new int[]{1,2,3} ;

• 静态初始化的简写格式

• 数据类型[] 数组对象名 = {元素1,元素2,元素3…} ; 推荐的写法

• 数据类型 数组对象名[] = {元素1,元素2,元素3…} ;

• int[] arr = {1,2,3} ;(推荐)

• int arr[] = {1,2,3} ;
  在数组中有一个特有的属性:length

• 数组名称.length:获取数组长度

• 数组中的最大索引值: 数组名称.length-1

数组的应用
已知一个数组:静态初始化了,现在需要把数组的元素遍历出来
遍历:将数组的元素一一打印出来;

package com.qf.array_03;
public class shuzu {
    public static void main(String[] args) {
//定义一个方法
    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]);
        }
    }
}

创建一个数组的注意事项
初始化的时候不能动静结合: 不能够同事动态和静态初始化,只能有一种
面试题
int[] array = new int[3] ; 这句话完了哪些事情? ----内存干了什么事
情
1)需要在栈内存中开辟 空间, int[] array这个变量
2)new int[3] ; 需要在堆内存中申请空间
3)为这个堆内存中的这些数组的元素,进行系统默认初始化,int类型的元素在
数组中默认值0
4)系统初始化完毕,为堆内存空间产生一个空间地址值,
5)将堆内存空间地址值赋值给栈内存的变量array
6)栈内存变量 array指向堆内存地址;

数组的其他基本应用

• 最值问题 (最大值/最小值),结合方法完成
  已知一个数组,静态初始化,完成获取数组中最大值
  *分析:

• int[] array = {65,45,76,87,13} ;
  1)定义一个参照物 array[0]就是最大值
  2)从角标1开始遍历数组的其他元素
  3)判断:使用后面的元素依次和参照物比较
  如果后面元素比参照物,将最大值修改了
  4)获取最大值;

package com.qf.array_01;
public class ArrayDemo {
    public static void main(String[] args) {
        //创建一个数组静态初始化
        int[] array = {65,45,76,87,13} ;
        //调用最大值
       int max = getArrayMax(array) ; //实际参数
        System.out.println("max2:"+max2);
        调用最小值
        int min = getArrayMin(array);
        System.out.println("min:"+min);
        //最大值
         public static int getArrayMax(int[] arr){
         //1)定义参照物
        int max  = arr[0] ;
          //2)从角标1开始遍历数组,获取每一个元素
        for(int x = 1 ; x < arr.length ; x ++){
            //判断
            if(arr[x] > max){
                //将后面的元素赋值给max
                max = arr[x] ;
            }
        }
        return  max ;
     System.out.println("-----------------------------------------") ;
      /**
     * 定义一个方法, 获取数组最小值
     *  两个明确
     *          1)明确返回值类型 int
     *          2)明确参数类型以及参数个数
     *                  int[] /1个参数
     *
     */
    public static int getArrayMin(int[] arr){
        //定义一个参照物 是最小值
        int min = arr[0] ;
        //从角标1开始遍历数组
        for (int i = 1; i < arr.length; i++) {
            //判断
            //如果后面的元素比min还小,后面的元素是最小值
            if(arr[i] < min){
                min = arr[i] ;
            }
        }
        return  min ;
    }

需求:

• 已知一个数组,静态初始化了,查询数组中某个元素的索引值/查询具体的元素
  int[] arr = {69,57,13,24,87} ; //查询13这个元素第一次出现的索引值
  //133元素

    分析:
         1) 定义一个方法
                方法的返回值 int
                方法的参数类型和参数个数
                 int[],查询的具体的元素   2个参数
        2)
              遍历数组,获取所有元素
              判断:如果要查询的元素和数组的中元素一致,就找到了
                        返回角标值
  

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);
       
        int index2 = getIndex(arr, 133);//找13
        System.out.println("index2:"+index2);

     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 ;
    }
    //查询具体的元素
    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 ;
    }
    }

冒泡排序

package com.qr.demo;

public class maopao {
    public static void main(String[] args) {
        int[] arr={45,89,54,82,96,34,25,20,0};
        System.out.println("排序前:");
        bian(arr);
        System.out.println("排序后:");
        maopao(arr);
        bian(arr);

    }
    //遍历
    public static void bian(int[] arr){
        System.out.print("[");
        for(int a=0;a< arr.length;a++){
            if(a == arr.length-1){
                System.out.println(arr[a]+"]");
            }else{
                System.out.print(arr[a]+", ");
            }
        }
    }
    //冒泡排序
    public static void maopao(int[] arr){
        for(int a=0;a< arr.length-1;a++){
            for(int b =0;b< arr.length-1-a;b++){
                if(arr[b]>arr[b+1]){
                    int temp = arr[b];
                    arr[b] = arr[b+1];
                    arr[b+1]=temp;
                }
            }
        }
    }
}

jvm的内存分配

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

**

面向对象

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

特点:
1)更符号生活中的思想行为习惯
2)让复杂的事情简单化
3)从执行者变成了指挥者

面向对象的三大特征:

• 封装
• 继承
• 多态

什么是类
类,是能够描述现实世界事物一组属性和行为的集合;
类和事物的关系:一一对应的关系
事物:一定现实真实存在的

• 学生事物属性: 姓名,身高, 年龄 等等…
• 行为: 主要目的学习…

Java中规定,需要定义类描述这个事物 ,Java中最基本单元就是类
代码体现 描述哪一个事物
class 类名{ //类名:满足标识符的规范: 见名知意 }

class Student{ 
//在代码体现出这个学生的属性 : 
//成员变量: 
}

.基本类型作为形式参数和引用类型(数组,类,接口) 作为形式参数的特点?(重点)
实际需求业务中,数组这种在后期用的不是很多,用的"集合" List,Set,Map(高级集合特性),支持长度可变的需求;

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

.类
描述现实世界事物的一组属性和行为,代码体现出来对某个事物的描述以及在对应的主方法中测试;
1)手机有品牌(brand),价格,颜色,内存等属性,
手机可以打电话,发短信,打游戏等行为,
请使用面向对象的方式描述手机并且进行定义一个PhoneTest类,在主方法中测 试手机类
2)学生有姓名,年龄,性别属性
学生主要行为就是学习,还可以玩游戏,
请使用面向对象的方式描述学生类并且定义一个StudentTest类,在主方法中测 试学生类

封装(关键字 权限修饰符—private)
如果学生的年龄,手机价格,赋值的时候可以随便赋值,可能出现非法数据"负数"
以后：描述事务的时候，需要定义类，类中的所有的成员变量（现实世界事物的属性) ,必须都是私有化private;

• 封装:
  就是将显示世界事物的属性隐藏了(加入一个关键字private),
  私有的,无法直接访问的,对外数据的安全性!(外界不能访问的)
  对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())

注意事项:
以后在书写的代码的时候,写一个类,描述真是存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private

• 面试题*: private关键字的特点?
  1)被private修饰的成员变量以及成员 方法只能在本类中访问
  2)可以修饰成员变量也可以成员方法,就是为了外 界不能直接访问
  3)被private修饰的成员变量/成员方法可以间接的通过通过的方法访问;

package com.qf.private_05;

//定义一个学生类:来描述学生事物
public class Student {

    //被private修饰的成员变量:只能在本类中访问,外界不能访问
    //属性私有化
    private String name ; //姓名
    private int age  ;  //年龄
    private String sex ;//性别

    //手写 ---公共的访问方法:给姓名,年龄,性别 赋值
    //setXXX():XXX就是属性名称 ,符合标识符的规范
    public void setName(String n)  { //方法需要形式参数: 等会传递"高圆圆"
           name =  n ;//把n的值赋值给成员变量name
    }

    //给年龄赋值
    public void setAge(int a){
        age = a ;
    }
    //给性别赋值
    public void setSex(String s){ //"女"
        sex = s ; //sex = "女"
    }

    //提供公共的getXXX():获取姓名,年龄,性别
    //获取姓名
    public String getName(){
        return name ;
    }
    //获取年龄
    public int getAge(){
        return  age ;
    }

    //获取性别
    public String getSex(){
        return  sex ;
    }


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

    //学习JavaSE
    public void studyJavaSE(){
        System.out.println("正在学习JavaSE之面向对象oop") ;
    }
    // 会敲代码
    public void codding(){
        System.out.println("每天日日夜夜敲代码...") ;
    }



}
package com.qf.private_05;

/**
 * 描述学生事物,
 *      学生事物有两个属性,姓名和年龄,性别
 *      定义成员show(),来展示学生信息
 *
 *      学生的行为: 学习JavaSE , 会敲代码
 *
 *      使用面向对象的方式,加入封装思想来测试学生事物
 *
 *    分析:
 *          学生事物----- 定义学生类
 *         1)分析属性
 *         姓名,                 String name;
 *          年龄,                 int age ;
 *          性别                  String sex ;
 *
 *                      类中成员变量(属性),全部私有化加入private
 *          2)分析事物行为:
 *          对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())
 *
 *              成员show(),来展示学生信息            public void show(){输出name,age,sex}
 *              学习JavaSE , 会敲代码               public void studyJavaSe()
 *                                               public void codding() 敲代码
 *
 */
public class StudentTest {
    public static void main(String[] args) {


        //描述具体的学生---创建学生对象 :类名 对象名 = new 类名();
       Student s = new Student() ;

       //对象名.成员变量 = 赋值;   //赋值这些值 肯定来数据库
        //s.name = "高圆圆" ;   //被private修饰的成员变量:只能在本类中访问,外界不能访问
       // s.age = 20 ;
       // s.sex = "女" ;

        //使用对象名.成员方法名() ;
        //给学生的信息赋值---调用setXXX()
        s.setName("高圆圆") ;
        s.setAge(43) ;
        s.setSex("女") ;

        System.out.println("学生的姓名是:"+s.getName()+",年龄是"+s.getAge()+",性别是:"+s.getSex());

        //调用这个学生的一些其他行为
        s.studyJavaSE();
        s.codding();




    }
}