关于JAVA语法

1. import java.util.scanner
   
3. public class ScannerDemo{
4.    public static void main(String[] args){
5.     
6.      Scanner scanner = new Scanner(System.in);
7.      System.out.print("请输入您的名字");
8.      System.out.print("喔嗨哟!%s!/n",scanner.next());
10.    }
11. }

Running Result : 请输入您的名字 : Finanshow  喔嗨哟！Finanshow

Java基础语法复习要点

第一.数据与运算

<1>数据类型(Primitive Type)

整数:short(2 byte) int(4 byte)  long(8 byte)

字节: Byte(1 byte)

浮点数: float(4 byte)  double (8 byte)
布尔数 : boolean (2 byte)

字符 :char  必须了解Uicode编码表 在Unicode出现之前有许多的字符编码标准美国的ASCII 西欧语言中的ISO 8859-1,中国的GB118030

<2>位运算:&(AND) ; | (OR) ; ^(XOR) ; ~(补码) ; <<(左移) ; >>（右移） ;

巧用位运算判断奇偶

((number&1)!= 0 ? '是' : '否'));

二进制中，奇数最右边肯定为1,偶数最右边肯定为0

整数4 : 00000100  整数1 : 00000001 AND后 00000000

整数3 : 00000011  整数1 : 00000001 AND后 00000001

PS：为了举例方便，运算时，INT类型要考虑32位长度而不只是8位，因为INT占据内存字节有4个BYTE

<3>递增(increment) 和 递减(decrement) 运算

++i; //相当于 i= i+1; 先对变量的值进行加法，然后再做赋值运算 同理--i;

i++; //先做赋值运算，再对变量i进行运算;

第二.装箱autoboxing与拆箱unboxing

装箱：将数据存入对象中,数据存在于stack，将其复制到heap中的行为叫装箱  

拆箱：将数据从对象中抽离

<1>The relationship between Class and Object类和对象之间的关系

回顾前面的基本数据类型:long,int,double,float,boolean,byte并不是对象，在J2SE5.0之前，如果要让基本数据类型像对象一样进行操作，要使用所谓的打包类(Wrapper):Long,Integer,Double,Float,Boolean,Byted鞥

1. //Example Code
3. public class WrapperDemo{
5.     public static void main(String[] args){
6.     
7.       int data1 = 10; 
8.       int data2 = 20;
9.       //使用integer打包int
10.       Integer data1Wrapper = new Integer(data1);
11.       Integer data2Wrapper = new Integer(data2);
12.       //转换为double 输出
13.       System.out.println(data1Wrapper.doubleValue()/3);
14.       // 比较两个数值
15.       System.out.println(data1Wrapper.compareTo(data2Wrapper)); 
16.      
17.     }
19. }

PS:J2SE5.0之后，提供autoBoxing自动打包机制

<2>自动装箱和拆箱

J2SE5.0之后提供的自动装箱功能，为了让我们了解"自动"在实际代码中的体现，让我们来重写上买你的代码

1. public class AutoBoxingDemo{
3.    public static void main(String[] args){
4.       //不用这样声明Integer data1Wrapper = new Integer(data1);
5.       Integer data1 = 10;
6.       Integer data2 = 20;
7.       System.out.println(data1.doubleValue()/3);
8.       System.out.println(data1.compareTo(data2));
10.    }
11.  
12. }

学习自动装箱和拆箱还有许多资源:

Autoboxing: http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html

第三:数组  JAVA中，数组不光是数据的集合，更是一个对象

<1>一维数组 int [] array = new int[10];//完整的数据定义方法

int [] array = new int[] {2,3,4,1,3};//不用声明数组的大小

通过数组的定义，我们可以看出来数组是int[]类型的引用，即对象

<2>二维数组

int [][] arr = {{1,2,3},{4,5,6}};//定义了一个2Row3Clumnd的数组

<3>JAVA中数组的高级特性,用对象的概念去看待数组

int [] arr = new int[]{1,2,3,4,5}

int [] temp1 = arr;

int [] temp2 = arr;

实际上是temp1,temp2,arr同时引用了同一个数组对象

<4>foeach 和 数组

int [] arr = {1,2,3,4,5,6,3};//new int []可以省略

for (int element : arr)

System.out.println(element);

第四 字符串 ：无论如何字符串运用得好不好，直接影响到程序的效率

<1> 字符串 在JAVA中以string的一个实例存在，每一个字符串对象本身会有几个可操作的方法

length();//取得字符串长度

equals();//判断源字符是否与目标字符串相等

toLowerCase();//转小写

toUpperCase();//转大写

<2>不可变字符串

string str = "Just";

str = "Justin";

怎么样实现刷新STR的值,原理跟引用有关，就是str重新指向了一个stack里面的内容为Justin而不是刚才那个stackJust

第五 封装 Enapusucation

<1>简单的对象分析过程:

  单纯问题,从问题中的名词来识别对象，复杂问题不一定行得通

OOP分析的相关书籍

Applying UML and Patterns;

An Intorduction to Object-Oriented Analysis and Design and the Unified Process ,Second Edition  By Craig Larman

<2>使用class定义类

PS：一个文件中可以定义很多个类但是只能有一个类是public 的，文件名称要跟这个public的类同名

关于static:静态成员属于类所有，通过类名称来操作存取static成员，静态方法不允许调用非静态成员，注意区别静态成员，非静态成员，非静态方法，静态方法之间的调用准则

1. //可以根据这个去了解之间的关系
2. class Example1
3. {  static public int a; //静态成员
4.    public int b;        //实例成员
5.    void  Meth1(){       //实例方法
6.         a=10;       //实例方法中可以访问本类的静态成员
7.         b=20;       //实例方法中可以访问本类的实例成员
8.    }    
9.    static void Meth2(){  
10.         a=30;       //静态方法能够访问本类的静态成员
11.         b=40;       //静态方法不能够访问本类的实例成员   
12.    }
14.   public static void Main(){
15.      Example1 E1=new Example1();    //产生类的实例E1
16.      Example1 E2=new Example1();    //产生类的实例E2
17.      E1.Meth1();        //调用非静态方法需使用类的实例
18.      //E1.Meth2();      //此语句出现错误，因为静态方法只能由类来调用
19.      System.out.print("a={0},b={1}",Example1.a,E1.b);
20.      //E2.a=50;     //此语句出现错误，因为静态成员只能通过类来访问
21.      Example1.a=Example1.a+50;      //静态成员只能通过类来访问
22.      E2.b=Example1.a+60;  //此语句正确，实例成员由对象来访问,静态成员由类来访问
23.      System.out.print("a={0},b={1}",Example1.a,E2.b);
24.   }
25. }

<3>关于方法

*重载OverLoad

*递归Recursion

举个递归求最大公因子的例子

1. private static int gcd(){
2.    
3.     if (n == 0)
4.             return m;
5.     else 
6.             return gcd(n , m%n); //辗转相除法
8. }
10. //循环求最大公因子
11. private static int gcd(int m, int n){
13.    int r;
14.    while(n != 0 ){ r = m%n ; m = n; n = r }
15. return m;
18. }