Java基础

变量类型

• 部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法.

public class student(){
    public student(){
    }
    //上下是两种不同的构造方法
    public student(String name)
}

类的声明

• 一个源文件中只能有一个public类
• 一个源文件可以由多个非public类
• 源文件的名称应该和public类的类名保持一致
• package有的话要放在第一行
• import有的话放在紧接着package之后

基本数据类型

java的两大数据类型

• 内置数据类型
• 引用数据类型（即自己创建的类，一旦申明就不能改变，不像内置的可以强制类型转化）

内置数据类型：byte（8）、short（16）、int（32）、long（64），float(32)、double（64）、boolean、char

查看数据类型的长度和最大最小值

System.out.println(Integer.SIZE)
System.out.println(Integer.MIN_VALUE)
System.out.println(Integer.MAX_VALUE)

Java中常量用final声明，变量名一般用大写

变量类型

局部变量：声明在方法构造方法或者语句块，执行完被销毁，访问修饰符不能用于局部变量，局部变量是在栈上分配的，局部变量没有默认值，必须初始化后才能使用

实例变量（成员变量）：在类中在方法、构造方法之外，当一个对象被实例化后，实例变量就跟着确定了。访问修饰符可以修饰实例变量。实例变量有默认值，数值型变量默认值为0，布尔型为false，引用类型变量为null

类变量（静态变量）：在类中以static关键字声明，但必须在方法、构造方法和语句块之外。静态变量除了被声明为常量之外很少被使用，很少单独用static声明的。静态变量在程序开始时创建，在程序结束时销毁。通过classname.variablename形式访问

Java修饰符

• 访问修饰符
  • 默认的，也称为default，在同一包内可见，不使用任何修饰符。
  • 私有的，以private修饰符指定，在同一类内可见。
  • 共有的，以public修饰符指定，对所有类可见。
  • 受保护的，以protected修饰符指定，对同一包内的类和所有子类可见。
• 非访问修饰符
  • static :创建类方法和类变量，静态方法不能使用类的非静态变量。静态变量也成为类变量，局部变量不能申明为static变量
  • final：修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。final对象的应用不能，但里面的值可以变
  • Abstract修饰符，用来创建抽象类和抽象方法。
  • Synchronized和volatile修饰符，主要用于线程的编程。

Java运算符

位运算：

&：按位与

^：异或

~：按位取补

<< >>：按位左移右移

>>> ：按位右移补0

逻辑运算：

&&：逻辑与

|| ：逻辑或

！ ：逻辑非

条件运算符（？：）

variavble x= (expression)? value if true :value if false
b =(a==1)? 20:30

Java循环结构

• while循环

• do。。while循环

• for循环，for循环除了常用的形式外，还有增强for循环

  for(声明语句：表达式)
  {
     //代码句子
  }
  int [] numbers ={10,20,30,40};
  for(int x:numbers){
      System.out.print(x);
  }
  

Java分支结构

if...else:

switch: 语句中的变量类型只能为byte、short、int 或者char

switch(expression){
    case value:
         //xxx
         break;
    case value:
         //xxxx
         break;
    default:
         //可选
}

Java Number类

使用内置数据类型的时候，使用的 是对象而不是内置数据了类型。Java语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类。这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number类属于java.lang包。

public class Test{

   public static void main(String args[]){
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

Number类有很多方法，比如 Integer a = 10,可以使用a.toString()返回字符串

Java Character类

java语言为内置数据类型char提供了包装类Character类，可以使用Character的构造方法创建一个Character类对象，例如：

//装箱
Character ch =new Character('a');
//可以对ch使用很多方法，比如isLetter(),isWhitespace()
//拆箱
ch =ch+'a'

Java String类

创建字符串

String greeting  = "hello world"
char[] helloArray ={'h','e','l','l','o'};
String hellostring = new String(helloArray)

获取字符串长度：

String test ="hello world"

拼接两个字符串：或者用加号

string1.concat(string2)

创建格式化字符串:

这样：

System.out.printf("my name is %s,%d years old",name,age);

或者

String fs;
fs =String.format("my name is %s,%d years old",name,age);
System.out.printf(fs)

下面是String支持的常用函数

1	xxxValue()将number对象转换为xxx数据类型的值并返回。
2	compareTo()将number对象与参数比较。
3	equals()判断number对象是否与参数相等。
4	valueOf()返回一个Integer对象指定的内置数据类型
5	toString()以字符串形式返回值。
6	parseInt()将字符串解析为int类型。
7	abs()返回参数的绝对值。
8	ceil()对整形变量向左取整，返回类型为double型。
9	floor()对整型变量向右取整。返回类型为double类型。
10	rint()返回与参数最接近的整数。返回类型为double。
11	round()返回一个最接近的int、long型值。
12	min()返回两个参数中的最小值。
13	max()返回两个参数中的最大值。
14	exp()返回自然数底数e的参数次方。
15	log()返回参数的自然数底数的对数值。
16	pow()返回第一个参数的第二个参数次方。
17	sqrt()求参数的算术平方根。
18	sin()求指定double类型参数的正弦值。
19	cos()求指定double类型参数的余弦值。
20	tan()求指定double类型参数的正切值。
21	asin()求指定double类型参数的反正弦值。
22	acos()求指定double类型参数的反余弦值。
23	atan()求指定double类型参数的反正切值。
24	atan2()将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25	toDegrees()将参数转化为角度。
26	toRadians()将角度转换为弧度。
27	random()返回一个随机数。

Java StingBuffer 和String Builder

当对字符串进行修改的时候，需要使用StringBuffer和StringBuilder类

StringBuilder方法不是线程安全的，但是比StringBuffer更有速度优势，所以大多情况下都使用StringBuilder。如果应用程序要求线程安全，那么就要使用StringBuffer

StringBuffer支持的主要方法：

1	public StringBuffer append(String s)将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end)移除此序列的子字符串中的字符。
4	public insert(int offset, int i)将 int 参数的字符串表示形式插入此序列中。
5	replace(int start, int end, String str)使用给定 String 中的字符替换此序列的子字符串中的字符。

自身调用就可以

public class Stringbuffertest {
    public static void main(String []args){
        StringBuffer aStringBuffer = new StringBuffer("qwer");
        aStringBuffer.append("da");
        System.out.println(aStringBuffer);
        aStringBuffer.reverse();
        System.out.println(aStringBuffer);      
    }
}

Java数组

数组声明：

datatType[] arrayname;
或者
dataType arrayname[];
eg:
double[] mylist;
或
double mylist[];

数组创建：

arryanem = new datatype[arraySize];

数组声明加创建：

dataType[] arrayname = new dataType[arraySize]
or
dataType[] arrayname ={value0,value1,value2}

数组的foreach循环

int[] test = {1,2,3,4,5};
for(int i:test){
    System.out.print(i);
}

Arrays类：

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

• 给数组赋值：通过fill方法。
• 对数组排序：通过sort方法,按升序。
• 比较数组：通过equals方法比较数组中元素值是否相等。
• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

int[] test ={1,2,3,4,5};
int index =Arrays.binarySearch(test,3);
Arrays.fill(test, 0);
Arrays.sort(test);

Java日期和时间

import java.util.Date;  
public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();       
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

使用SimpleDateFormat格式化日期:

import java.util.*;
import java.text.*;
public class DateDemo {
   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
      System.out.println("Current Date: " + ft.format(dNow));
   }
}

prinf格式化日期 用%t

Java休眠（sleep）毫秒

Thread.sleep(5*60*10);

测量时间

long start = System.currentTimeMillis( );
long end = System.currentTimeMillis( );
long diff = end - start;

Calendar类:（用的时候再查吧）

Calendar c = Calendar.getInstance();//默认是当前日期
c.set(2009,6-1,12)

Java正则表达式

跟python差不多，创建pattern-->创建pattern对象-->创建matcher对象-->查找

语法用的时候查

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Zebds {
    public static void main(String []args){
        String line ="this order was placed for Q3000! ok?";
        String pattern ="(.*)(\\d+)(.*)";
        Pattern r =Pattern.compile(pattern);
        Matcher m = r.matcher(line);
        if(m.find()){
            System.out.println("Found value: " + m.group(0) );
             System.out.println("Found value: " + m.group(1) );
             System.out.println("Found value: " + m.group(2) );
        }
        else{
            System.out.println("error");
        }
    }
}

Java方法

可变参数：方法申明中，在指定参数类型后加一个省略号（...）,一个方法中只能有一个可变参数，任何普通参数必须在它之前声明

public class ChangeValue {
    public  static void main(String args[]){    
        sayhello(10,"wer","fff");
    }   
    public  static void sayhello(int age,String...agrs){
        System.out.printf("i am %d years old and i am %s,and %s",agrs[0],agrs[1]);
    }
}

finalize()方法：Java允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做finalize( )，它用来清除回收对象。finalize()方法写在要被实例化的类中，当实例对象被回收的时候被调用。

finalize()一般格式是：

protected void finalize()
{
   // 在这里终结代码
}

关键字protected是一个限定符，它确保finalize() 方法不会被该类以外的代码调用。Java的内存回收可以由JVM来自动完成。如果你手动使用，则可以使用上面的方法。

eg:

class Student{
    String name;
    public Student(String aname){
        name =aname;
        System.out.printf("this is student %s",this.name);
    }
    protected void finalize() throws java.lang.Throwable{
        super.finalize();
        System.out.printf("%s is being exectude",this.name);    
    }   
}
public class Finalizetest {
    public static void main(String args[]){
        Student aStudent = new Student("wdp");
        Student bStudent = new Student("ws");
        aStudent =bStudent =null;
        System.gc();    
    }
}