JAVA2011第二周总结

1.switch语句

1.switch
选择结构语句之switch它的标准结构:
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;

…
…

default:
语句n+1;
break ;

}
执行流程:
首先switch中的表达式(值)和case后面值1先进行匹配,如果成立,执行语句1, 遇见break 结束了;
如果不成立,继续判断case 值2和表达式(值)是否匹配,如果成立,执行语句2,break,结束;
如果还不成立,继续依次判断case 后面的值是否匹配…
如果上面的case都不匹配,那么执行default中的语句,遇见break 结束!
switch语句中的注意事项
1)case语句的后面只能是常量,不能是变量

  2)关于break的意思: 结束,中断*   

switch语句的结束条件
(1) 遇见break结束!
(2) 程序默认执行到末尾!

  3)default语句可以放在switch语句中的任何位置,不影响程序的流程,但是
 如果在语句中,break不能省略的,如果在末尾,break 可以省略!

4)如果default语句在语句中,break语句不能省略,否则造成case穿透现象!(没有遇见break,不会和case进行比较,直接依次执行)

2.for循环

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

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

3.while循环

while循环的格式
基本格式

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

扩展格式
初始化语句;
while(条件判断语句){
循环体语句;
控制体/步长语句;
}
流程:
初始化语句执行一次
判断条件是否成立,成立,则执行循环体,再依次执行步长语句;
…
如果不成立,while循环语句结束!
while和for的区别
1)格式不同
2) 并且从内存角度考虑:

       for循环的 格式:  for循环语句外面不能够访问变量的,因为它随着for循环执行完毕,main方法结束之后,变量就会被GC(垃圾回收器)回收掉这些变量
       while循环的扩展格式:循环结束,依然可以访问变量; 在内存中占用资源空间大于for循环

3)如果明确循环次数,优先使用for
不明确循环次数,使用while循环
break的使用场景:
switch语句中,循环语句中使用
while和for的区别
1)格式不同
2) 并且从内存角度考虑:

       for循环的 格式:  for循环语句外面不能够访问变量的,因为它随着for循环执行完毕,main方法结束之后,变量就会被

GC(垃圾回收器)回收掉这些变量
while循环的扩展格式:循环结束,依然可以访问变量; 在内存中占用资源空间大于for循环

3)如果明确循环次数,优先使用for
 不明确循环次数,使用while循环

在程序中出现—死循环

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

   for(;;){
       语句;
   }


   while(true){

     语句...
   }

4.do-while循环

do-while循环
格式

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

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

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

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

5.for循环嵌套

•  for(初始化语句;条件表达式;步长语句){
  

•      //内层循环是外层循环的循环体语句
  

•      for(初始化语句;条件表达式;步长语句){
  

•              循环体语句;
  

•      }
  

•  }
  

将内层循环看成是外层循环的循环体语句;
需求:
控制台输出形(4行5列的*)

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

6.跳转控制语句

break :中断,结束
continue : 继续(循环中使用,结束当前循环,立即进入下一次循环)
return :结束方法(和方法相关)

break
break :单独不能使用
1)在循环中和switch中用
循环中:
单层循环中使用
2) for循环嵌套中使用
标签语句
在外层循环
和内层循环的外面使用 标签名:外层循环/内层循环
break 后面跟标签名称;

3行3列的*
 *                wc:for(int x = 0 ; x < 3 ;  x ++){
 *                      nc:for(int y = 0 ; y <3 ; y ++){
 *
 *                      }
 *
 *                  }
 *
 */
public class BreakDemo {

    public static void main(String[] args){
         //break ; //单独使用不了

      /*  for(int x = 0 ; x < 10 ; x ++){

            if(x == 3){
                break ; //单层循环中使用
            }
            System.out.println(x) ; //0,1,2,
        }*/

      //for循环的嵌套:3行4列的*
        //带标签的语句:很少用(了解)
        wc:for(int x = 0 ; x < 3 ; x ++){
           nc: for(int y = 0 ; y < 4 ; y++){
                if(y==2){
                    //break wc ; //break 标签名称;
                    break nc; //结束内层循环
                }
                System.out.print("*");
            }
            System.out.println() ;
        }
        System.out.println("----------------------------") ;



        System.out.println("over") ;
    }
}

continue
continue : 继续(循环中使用,结束当前循环,立即进入下一次循环)
*

•  应用场景:循环中使用
  

 面试题
          补全空白处代码
          for(int x =1 ; x <=10 ; x ++){
 *             if(x % 3== 0){
 *                 ____补全代码______
 *             }
 *             System.out.println("Java基础班") ;
 *        }
 *        需求:
 *        1)想在控制台输出输出2次"Java基础班"
 *              break
 *        2)想在控制台输出7次"Java基础班"
 *              continue
 *        3)想在控制台输出13次"Java基础班"
 *                 System.out.println("Java基础班") ;
 */
public class ContinueDemo {
    public static void main(String[] args){

        //一个for循环
        for(int x = 1 ; x <= 10 ; x ++){

           // if(x == 3){
            if(x % 3 ==0){
                continue;//结束当前循环,立即进入下一次循环
            }

            System.out.println(x) ;
            //1,2,4,5,7,8,10
            //0,1,2,4,5,6,7,8,9
        }
        System.out.println("over") ;
    }

}

• return
  return:要结合方法使用的,一般很少单独使用

```java
public class ReturnDemo {

    public static void main(String[] args){

        System.out.println("程序开始了..") ;
        for(int x = 0 ; x <10 ;x ++){
            if(x == 2){
                System.out.println("中途退出了...") ;
                //break ;
               // continue;
                return ; //方法终止了!
            }

            System.out.println(x) ; //0,1
        }

        System.out.println("voer,结束了...") ;

    }

7.方法

在Java中什么是方法呢?
方法 (一个独立的代码块{}):将共性内容抽取出来,使用{}包裹起来,为{}起名字 举例:
植物大战僵尸—豌豆芽–发送炮弹
发送炮弹(是一个程序)要在任何地图上都要使用,给发送炮弹这个程序 抽取出来
给独立起一个名字使用{}将代码包裹起来 ,将名字–方法名,每次 "发送炮弹"地方,只需要调用方法名即可!
重点:
如何定义一个方法
第一种格式:有具体返回值(数据类型)的方法

     形式参数列表
权限修饰符 + 静态修饰符 + 具体的返回值类型 + 方法名(数据类型1 变量名1 ,数据类型2 变量名2 ,....){
              //完成的业务逻辑
              return 结果;
        }             

详细解释:

•  权限修饰符 :public
  

•  静态修饰符:static(带上)
  

•  具体的返回值类型:数据类型 (目前学习过的基本类型:没有告诉什么类型,都是默认int)
  

•  方法名: 符号 标识符的规则: 小驼峰命名法:
  

•              一个单词:字母全部小写
  

•              多个单词:第一个单词小写,从第二个单词开始:每个单词首字母大写
  形式参数列表:
          数据类型1(目前学习过的基本类型:没有告诉什么类型,都是默认int) + 参数名1(变量名) ,  数据类型2 参数名2..
  return :结束方法: 必须返回具体结果;
  

定义方法有两个明确:
1)明确返回值类型
2)明确参数类型以及参数个数
调用方法:
1)单独调用:(没有输出)没有意义
2)输出调用:输出:写死了,不利于值的进一步操作
3)赋值调用(推荐)
定义方法的注意事项:
1)方法与方法是平级关系 ,不能再一个方法中定义另一个方法 (不能再方法中定义)
2)Java是强类型语言 (语法结构非常严谨) 弱类型语言:前端:javascript (定义方法:不需要携带数据类型)

      定义形式参数:必须携带数据类型

3)调用方法的时候
数据类型 变量名 = 方法名(实际参数列表) ;实际参数如果定义了,传递参数,不需要携带类型

4)目前我们定义的方法都是有方法体的 (有左大括号"{ 的地方不能有分号; 有分号;的地方不能有左大括号"{" )
权限修饰符 + 静态修饰符 +返回值类型 +方法名(形式参数列表){
}
没有具体返回值类型的方法定义以及如何调用
Java语法规定:当一个方法没有具体返回值类型的时候,使用void 代替

2)方法的重载

Java提供一个技术:方法重载 (overLoad)
含义:
多个方法的方法名相同,参数列表不同,与返回值无关 —将这些方法称为"方法重载" ------- 面向对象部分:(继承) 方法重写(override)
参数列表不同有两种情况
1)参数个数不同 (参数类型一致)
2)参数类型不一致(参数个数一致)

8.数组概述

数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致

数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义的格式
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
1:针对数组定义两种格式，推荐使用第一种格式。因为第一种的可读性更强。
*注意：这两种定义做完了，数组中是没有元素值的。
数组的初始化
数组初始化概述
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
引用类型:一旦对象创建了,地址值永远固定,除非重新new 新的对象,才产生一个新的地址!
Java中的内存分配
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，
因为每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量
堆 存储new出来的东西
方法区（面向对象部分讲）
本地方法区（和系统相关）
寄存器（给CPU使用）
1：局部变量
a:方法定义中或者方法声明上的所有变量
b:使用完毕，立即消失2：new出来的东西，实体，对象。
new int[3];
a:每一个实体都有首地址值
b:每一个实体内的数据都有默认值
byte,short,int,long 0
flfloat,double 0.0
char ‘\u0000’
boolean false
引用类型：null
c:使用完毕后，会被垃圾回收器空闲的时候回收。
其实讲解完堆和栈的区别，大家就能够理解刚才为什么输出的是地址和0了。
静态初始化
初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};
注意事项:
int[] arr = new int[5]{11,22,33,44,55} ;
//错误的:数组初始化只能有一种:不能既动态初始化,又静态初始化
数组中常见的两个小问题
数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
出现错误的原因:
开发者在书写代码的时候导致,角标值超出了数组的长度
解决方案: 只要正常访问角标值就可以
空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素时
出现的原因:
某个对象(数组)已经为null了,堆内存中没有空间地址值了,开发者还试图访问这个对象(数组)中的元素,就会有问题
解决方案:
针对对象:进行逻辑判断
如果对象不为null,再去访问;
将一个数组进行逆序排列

  /**
     *定义一个逆序的方法
     * 两个明确:
     *  1)明确返回值类型:void (没有具体返回值类型)
     *  2)明确参数类型以及参数个数
     *   int类型的数组,1个参数
     *
     *
     * int a= 10 ;
     * int b = 20 ;
     * 交互a,b的值
     */
    public static void reverse(int[] arr){//数组
        //第一次互换
        //中间变量 (开发中常用)
        /*int temp = arr[0] ;
        arr[0] = arr[arr.length-1-0] ;
        arr[arr.length-1-0] = temp ;

        //第二次互换
        temp = arr[1] ;
        arr[1] = arr[arr.length-1-1] ;
        arr[arr.length-1-1] = temp ;*/

        //第三次互换
        //..
        //...

        // 保证当前元素的范围:角标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 ;
        }

    }

    //遍历的功能
    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]+", ") ;
            }

        }
    }

查询数组角标的方法

//定义一个数组,静态初始化
        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);
    }

9.面向对象

前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应
的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将
这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？
通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作
时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
面向对象思想概述以及特点
思想概述:
面向对象是基于面向过程的编程思想
特点：
1.是一种更符合我们思想习惯的思想
2. 可以将复杂的事情简单化
3. 将我们从执行者变成了指挥者角色发生了转换
面向对象思想举例
买电脑
吃饭
洗衣服
万事万物皆对象
类与对象关系
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。 我们如何表示一个现实世界事物呢： 属性 就是该事物的描述信息 行为 就是该事物能够做什么
举例：学生事物 我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
类与对象关系
类：是一组相关的属性和行为的集合
类—Java中的最基本单元
对象：是该类事物的具体体现(应该是指定的某个类中具体的事物)
类的定义
现实世界的事物 属性 人的身高，体重等 行为 人可以学习，吃饭等Java中用class描述事物也是如此
成员变量: 就是事物的属性
成员方法: 就是事物的行为 定义类其实就是定义类的成员(成员变量和成员方法)
1:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
2:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
面对对象的基本特点

面向对象本质就是基于面向过程:


  面向过程:代表语言就C语言
    需求:给定义数组,获取数组中的最大值
     1)创建数组
     2)遍历数组
     3)业务逻辑判断
       假设法(定义一个参照物是最大值)
       遍历数组时候,将后面的元素依次和它比较
       如果后面的元素比它大,后面的元素就是最大值
     4)输出结果...

   面向对象:代表就是Java


   生活中的例子:

        买电脑:
            面向过程:
                    1)制定自己的需求(什么的电脑配置)
                    2)去赛格电脑城
                    3)讨价还价
                    4)支付价钱
                    5)买到电脑

            面向对象:
                   1)制定自己的需求(什么的电脑配置)
                   2)找一个懂行的朋友(面向过程)
                   3)他给我买到电脑

        做饭
            面向过程:
                    1)买菜
                    2)讨价还价
                    2)摘菜
                    4)洗菜
                    5)切菜
                    6)炒菜
                    7)出锅...

            面向对象:
                   1)找一个对象
                   2)等待出锅..

        洗衣服:
            面向过程:
                    1)脱下脏衣服
                    2)找一个盆
                    3)加入洗衣液_水
                    4)将衣服泡一泡
                    5)搓一搓
                    6)透一透
                    7)拧一拧
                    8)晾一晾...


            面向对象:
                    1)脱下脏衣服
                    2)全自动洗衣机
                    3)一键完成..


生活中处处皆对象...
    面向对象的思想特点:
        1)更符合生活中的思想行为习惯
        2)将复杂的事情简单化
        3)让我们从执行者变成指挥者(角色发送变化了)



    Java语言的面向对象特征:
        封装,继承.多态!

    Java面向对象语言设计原则:
        可以不断的创建对象,使用对象,然后指挥对象做事情!

      键盘录入数据:
            Scanner类  ---- 完成对象 的创建以及录入的数据


  需求:
    将大象装进冰箱!

  伪代码
    面向过程:一步一步分析,一步一步完成

            测试类:Demo
            class Demo{
                public static void main(String[] args){

                    open() ;//开冰箱门

                    in() ;//将大象装进去


                    close() ;//关闭冰箱门
                }

                /*
                    定义冰箱开门的功能
                */
                public static void open(){
                    输出---"打开冰箱门"
                }

                /*
                    定义一个大象进去的功能
                */
                public static void in(){
                    输出---"将大象装进去"
                }

                /*
                    定义冰箱关门的功能
                */
                  public static void close(){
                         输出---"关闭冰箱门"
                 }
            }


    面向对象:  Java语言:中 ---最基本的单元是类

             将大象装进冰箱!

             1)分析有哪些类
             2)类中有什么东西
               大象类---进去的功能
               冰箱--- 开门和关门的功能
               测试类---main方法---主程序(程序的入口)

           分析:UML :名词提前法
           大象----大象类
           冰箱----冰箱类
           测试类:Demo

           class 大象类{
                public static void in(){
                    System.out.println("大象进去...") ;
                }
           }


           class 冰箱类{

               public static void open(){
                    System.out.println("打开冰箱门") ;
               }

                 public static void close(){
                     System.out.println("关闭冰箱门") ;
                 }
           }


           测试类:Demo

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

                        //能够创建冰箱类对象
                        冰箱类对象.open() ;
                        //如果能够创建大象类对象
                        大象类对象.in() ;
                        冰箱类对象.close() ;
                }

           }

类与对象的关系

类---Java中的最基本单元
    描述现实世界事物的属性和行为的集合!


    描述现实世界真是存在的事物:
分析:
    学生事物

        属性:姓名,年龄,身高,性别
        行为: 学生 主要学习
              学生可以玩游戏(会玩高端:吃鸡游戏/steam:战地/....)



    将上面的分析真实存在的事物-----变成Java代码(程序方式描述)


    学生类 (统称)
        将事物的属性-----成员变量(类中,方法外)
                        (name,age,high,gender)

        将事物的行为-----成员方法(和我们之前学习的方法是一样的,去掉static)
                                public 有返回值类型 方法名(形式参数列表){
                                        return 结果;
                                }

                             public void 方法名(形式参数列表){
                                     输出...
                              }

类和对象的关系
    对象:应该是指定的某个类中具体的事物
    学生事物
                张三
                李四


    class Student{
        //定义成员变量 (学生事物的属性)
        //定义成员方法(学生事物的行为)

    }

    //测试类中

        对象:描述具体事物
        创建对象的格式:
        类名 对象名 = new 类名() ;
        Student s = new Student() ;

        //给学生赋值:姓名,年龄,身高,性别
        对象名称.成员变量= 赋值;
        //使用学生的行为:访问成员方法
        对象名.方法名() ;

匿名对象
匿名对象：就是没有名字的对象。
是对象的一种简化表示形式
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递
匿名对象:顾名知意: 没有名字的对象
类名 对象名 = new 类型() ; 有名字的对象

//1:new Student().show();
//2:new StudentTest().method(new StudentDemo());

匿名对象的格式:
new 类名() ;
new 类名().成员方法名() ; 访问当前类中的成员方法
特点:
1)匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!
应用场景:都是在移动端使用居多—Android :基于Java (大部分都是使用匿名对象,节省内存)
2)开发中,匿名对象使用一次即可,不要使用多次! (使用完毕,就立即被回收)
3)匿名对象可以作为参数传递
封装
Java提供一个关键字:private 封装
封装概述
封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

/**
 * 需求:
 *      学生事物,
 *          属性:姓名,年龄,性别
 *          行为:学习,爱好...
 *
 *        使用Java程序描述学生事物并且进行测试
 *
 * 注意:
 *      同一个包下(文件夹)不能存在同一个类名
 *
 *
 *
 *
 */
class Student2{

    //成员变量私有化
    private String name ; //姓名
    private int age ; //年龄
    private String sex ;//性别


    //对外提供成员变量的公共的访问
    //setXXX(xxx):赋值
    //getXXX():获取值

    //给姓名赋值 的成员方法
    public  void setName(String n) { //"高圆圆"
        name = n ;  //name = "高圆圆"
    }

    //获取name的成员方法
    public  String getName(){

        return name ; //"高圆圆"
    }

    //给年龄赋值
    public void setAge(int a){ //a=23
        age = a ;//23
    }

    //获取年龄的值
    public int getAge(){
        return age ;//23
    }

    //给性别赋值
    public void  setSex(String s){//s="女"
        sex =  s ;
    }

    //获取性别
    public String getSex(){
        return sex ; //"女"
    }
    //成员方法
    public void study(){
        System.out.println("学习JavaEE...");
    }
    //爱好
    public void hobit(){
        System.out.println("爱生活,爱Java...");
    }
}
//测试类
public class StanderClass {
    public static void main(String[] args){

        //创建一个具体的对象:
        //类名 对象名 = new 类名() ;
        Student2 s = new Student2() ;

        //给成员变量
       /* s.name = "高圆圆";
        s.age = 23 ;
        s.sex = "女" ;*/

       //name,age,sex 三个属性已经私有化了,只能本类中访问,外界不能访问
        //外界访问----通过公共的访问方法来访问:

        //提供公共访问
        s.setName("高圆圆");
        s.setAge(23);
        s.setSex("女");

       // System.out.println(s.name+"---"+s.age+"----"+s.sex);

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

关键字
1)private关键字
private关键字：
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
2)this关键字
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...");
    }
}