变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如 myAge

比较运算符可用于输出

例：

public class mu12{

public static void main[]args{

int a=5;

double b= 5.4;

System.out.println(“a大于b是”+(a>b））；

输出为“a大于b是false”。 

常量名一般使用大写字符

标识符就是用于给 Java 程序中变量、类、方法等命名的符号。

 1.  标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴

 2.  标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以

 3.  标识符是严格区分大小写的。 所以涅，一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！

 4.  标识符的命名最好能反映出其作用，做到见名知意。

Java条件语句之 switch

public class HelloWorld {
    public static void main(String[] args) {
       
        // 变量保存成绩
        int score = 53;
       
        // 变量保存加分次数
        int count = 0;

        System.out.println("加分前成绩:"+score);
        //打印输出加分前成绩
        while(score<60) 
       {
           score++;
           count++;
       }
       
        // 只要成绩小于60，就循环执行加分操作，并统计加分次数
       
        System.out.println("加分后的成绩:"+score);
        System.out.println("共加了"+count+"次！");
       
       
       
       
        //打印输出加分后成绩，以及加分次数
     

    }
}

逻辑运算符主要用于进行逻辑运算。Java 中常用的逻辑运算符如下表所示：

我们可以从“投票选举”的角度理解逻辑运算符：

1、 与：要求所有人都投票同意，才能通过某议题

2、 或：只要求一个人投票同意就可以通过某议题

3、 非：某人原本投票同意，通过非运算符，可以使其投票无效

4、 异或：有且只能有一个人投票同意，才可以通过某议题

当使用逻辑运算符时，我们会遇到一种很有趣的“短路”现象。

譬如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。

同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行啦！

任务

没懂引用类型！！！

在Java中类型可分为两大类：值类型与引用类型。值类型就是基本数据类型（如int ,double 等），而引用类型,是指除了基本的变量类型之外的所有类型（如通过 class 定义的类型）。所有的类型在内存中都会分配一定的存储空间(形参在使用的时候也会分配存储空间,方法调用完成之后,这块存储空间自动消失), 基本的变量类型只有一块存储空间(分配在stack中), 而引用类型有两块存储空间(一块在stack中,一块在heap中)，在函数调用时Java是传值还是传引用，这个估计很多人至今都很糊涂，下面用图形与代码来解释：

　　在上图中引用类型在传参时不是在heap中再分配一块内存来存变量c 所指向的A(),而是让a 指向同一个A 的实例，这就与C++ 中的指针一样，先声明指针变量a,b,c,d 在传参的时候让a 指向c所指向的内存，让 d 指向 b 所指向的内存。很明显Java中的引用与C++中的指针在原理上是相类似的，但记住Java没有指针，只有引用。下面再通过一些具体的代码来讨论引用：

1. 简单类型是按值传递的

Java 方法的参数是简单类型的时候，是按值传递的 (pass by value)。这一点我们可以通过一个简单的例子来说明：

package test;

public class Test {

   //交换两个变量的值

   public static void Swap(int a,int b){

      int c=a;

      a=b;

      b=c;

      System.out.println("a: "+a);

      System.out.println("b: "+b);

   }

   public static void main(String[] args){

      int c=10;

      int d=20;

      Swap(c,d);

      System.out.println("After Swap:");

      System.out.println("c: "+d);

      System.out.println("d: "+c);

   }

}

运行结果：

a: 20

b: 10

After Swap:

c: 20

d: 10

　　不难看出，虽然在 Swap (a,b) 方法中改变了传进来的参数的值，但对这个参数源变量本身并没有影响，即对 main(String[]) 方法里的 a,b 变量没有影响。那说明，参数类型是简单类型的时候，是按值传递的。以参数形式传递简单类型的变量时，实际上是将参数的值作了一个拷贝传进方法函数的，那么在方法函数里再怎么改变其值，其结果都是只改变了拷贝的值，而不是源值。

2. 什么是引用

　　Java 是传值还是传引用，问题主要出在对象的传递上，因为 Java 中简单类型没有引用。既然争论中提到了引用这个东西，为了搞清楚这个问题，我们必须要知道引用是什么。

　　简单的说，引用其实就像是一个对象的名字或者别名 (alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C++ 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。

如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间（stack，栈空间）来保存。但是它们的值是相同的，都指示同一个对象在内存（heap，堆空间）的中位置。比如：

      String a="This is a Text!";

      String b=a;

　　通过上面的代码和图形示例不难看出，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 "This is a Text!"。但要注意String 对象的值本身是不可更改的 (像 b = "World"; b = a; 这种情况不是改变了 "World" 这一对象的值，而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。

　　如图，开始b 的值为绿线所指向的“Word Two”，然后 b=a; 使 b 指向了红线所指向的”Word“.

这里我描述了两个要点：

（1） 引用是一种数据类型（保存在stack中），保存了对象在内存（heap，堆空间）中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)；

（2） 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。

3. 对象是如何传递的呢

　　随着学习的深入，你也许会对对象的传递方式产生疑问，即对象究竟是“按值传递”还是“按引用传递”?

（1）认为是“按值传递”的：

package test;

public class Test {

      public static void Sample(int a){

         a+=20;

         System.out.println("a: "+a);

      }

      public static void main(String[] args){

         int b=10;

         Sample(b);

         System.out.println("b: "+b);

   }

}

运行结果：

a: 30

b: 10

    在这段代码里，修改变量 a 的值，不改变变量 b 的值，所以它是“值传递”。

（2）认为是“按引用传递”的：

package test;

public class Test {

      public static void Sample(StringBuffer a){

         a.append(" Changed ");

         System.out.println("a: "+a);

      }

      public static void main(String[] args){

         StringBuffer b=new StringBuffer("This is a test!");

         Sample(b);

         System.out.println("b: "+b);

   }

}

运行结果：

a: This is a test! Changed

b: This is a test! Changed

　　在Sample(StringBuffer)这个函数中，修改了引用 a 的值，同时 b 的值也变化了，所以它是“按引用传递”的！

　　那么对象（记住在Java中一切皆对象，无论是int a;还是String a;，这两个变量a都是对象）在传递的时候究竟是按什么方式传递的呢？其答案就只能是：即是按值传递也是按引用传递，但通常基本数据类型（如int,double等）我们认为其是“值传递”，而自定义数据类型（class）我们认为其是“引用传递”。

4. 正确看待传值还是传引用的问题

　　要正确的看待这个问题必须要搞清楚为什么会有这样一个问题。

　　实际上，问题来源于 C，而不是 Java。

　　C 语言中有一种数据类型叫做指针，于是将一个数据作为参数传递给某个函数的时候，就有两种方式：传值，或是传指针。 在值传递时，修改函数中的变量值不会改变原有变量的值，但是通过指针却会改变。

    void Swap(int a,int b){ int c=a;a=b;b=c;}

    void Swap(int *a,int *b){ int c=*a;*a=*b;*b=c; }

    int c=10;

    int d=20;

    Swap(c,d);    //不改变 c , d 的值

    Swap(&c,&d);  //改变 c , d 的值

　　许多的 C 程序员开始转向学习 Java，他们发现，使用类似 SwapValue(T,T)(当T 为值类型时) 的方法仍然不能改变通过参数传递进来的简单数据类型的值，但是如果T时一个引用类型时，则可能将其成员随意更改。于是他们觉得这很像是 C 语言中传值/传指针的问题。但是 Java 中没有指针，那么这个问题就演变成了传值/传引用的问题。可惜将这个问题放在 Java 中进行讨论并不恰当。

　　讨论这样一个问题的最终目的只是为了搞清楚何种情况才能在方法函数中方便的更改参数的值并使之长期有效。

5. 如何实现类似 swap 的方法

　　传值还是传引用的问题，到此已经算是解决了，但是我们仍然不能解决这样一个问题：如果我有两个 int型的变量 a 和 b，我想写一个方法来交换它们的值，应该怎么办？有很多方法，这里介绍一种简单的方法：

package test;

public class Test {

      public static void Swap(int[] a){

         int c=a[0];

         a[0]=a[1];

         a[1]=c;

      }

      public static void main(String[] args){

         int[] a=new int[2];

         a[0]=10;

         a[1]=20;

         Swap(a);

         System.out.println(a[0]);

         System.out.println(a[1]);

   }

}

　　通过数组可以方便的实现值类型的数据源的交换，不过还有一种方法是将所有变量封装到一个类里面去，通过引用类型来实现。

数组名.length  用于获取数组的长度

Java条件语句之 if...else

if (条件的布尔表达式) {

代码块1

}else{

代码块2

}

=是赋值符号

==是等于

比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。

Java 中常用的比较运算符如下表所示：

注意哦：

1、  > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型

2、  == 、 != 两边的操作数既可以是数值类型，也可以是引用类型

Java条件语句之 if

if (条件) {

       条件成立时执行的代码

）

java语言中==是等于，=是赋值。

声明数组的的方法

语法：  数据类型[ ] 数组名；

或者   数据类型 数组名[ ]；

声明数组、分配空间和赋值合并完成

数组下标从0开始

//通过Arrays来实现排序问题

import java.util.Arrays;

public class HelloWorld {
   
    //完成 main 方法
    public static void main(String[] args) {
       
        // 创建对象，对象名为hello
  HelloWorld hello = new HelloWorld();
       
        // 调用方法并将返回值保存在变量中
        int maxScore = hello.getMaxAge();
       
  // 输出最大年龄
  System.out.println("最大年龄为：" + maxScore);
 }

 /*
  * 功能：输出学生年龄的最大值
     * 定义一个无参的方法，返回值为年龄的最大值
     * 参考步骤：
     * 1、定义一个整形数组 ages ，保存学生年龄，数组元素依次为 18 ,23 ,21 ,19 ,25 ,29 ,17
     * 2、定义一个整形变量 max ,保存学生最大年龄，初始时假定数组中的第一个元素为最大值
     * 3、使用 for 循环遍历数组中的元素，并与假定的最大值比较，如果比假定的最大值要大，则替换当前的最大值
     * 4、使用 return 返回最大值
  */
 public int getMaxAge() {
     int ages[]={18 ,23 ,21 ,19 ,25 ,29 ,17};
     
         Arrays.sort(ages);
         int max=ages[ages.length-1];
         return max;
   
 }
}