java基础

发表于 | 分类于 | 阅读次数:
字数统计: 5,150字 | 阅读时长 ≈ 21分钟

此片文章适合刚开始学习java的人，内容非常的基础并且简单易懂。如果有一定的java基础的话可以忽略此文。

变量与常量

变量

 顾名思义，变量就是值可以变化的量。它是用于标识数据的存储单元，可用于数据存储和运算。

变量的定义

 变量定义的一般格式如下：

1
2
<数据类型><数据标识符(取个名字)>=<值>
如:double x = 3.1415;

 变量赋值后可以修改变量的值，格式如下：

1
2
<变量标识符(变量的名字)>=<值>  
如:x = 6.666;

 注意:在java中的变量，都需要先声明再赋值！

变量的作用域

  • 所谓的作用域就是在变量在什么时候是可见在什么是不可见的！
  • 作用域决定变量“可见性”与“存在时间”。
  • 作用域的范围：只作用于从声明开始到所在的{}结束。

    变量

     常量有字面常量和符号常量两种。

    符号常量

     符号常量指用标识符表示的常量。定义的一般格式如下：
    1
    2
    3
    4
    <final><数据类型><符号常量标识符>=<常量值>;
    例如：
    final double PI = 3.1415926; 
    final String name = "Tom";

 常量一旦赋值不能修改!

字面量

 字面量就是直接给值 不声明变量储存例如int a = 0;a = a + 3; a 是一个int型变量 3是字面量,又String s = “字符串”;s是变量”字符串”是一个字面量。

数据类型

基本数据类型

 基本数据类型：基本数据类型时不能简化的、内置的数据类型、由编程语言本身定义，它表示了真实的数字、字符和整数。

 在java中有8种基本数据类型，分别是:
  1.byte:Java中用户表示最小数据单位，在内存中占8位(bit)，即一个字节，取值范围-128~127，默认值0。
  2.short：短整形，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0。
  3.int：整形，在内存中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0。
  4.long:长整形，在内存中占有64位，即8个字节，取值范围-2^63~2^63-1，默认值0L。
  5.float：浮点型，在内存中占32位，即四个字节，用于存储带小数点的数字(与double的区别在于float类型有效小数点只有6~7位)，默认值0.0。
  6.double：双精度浮点型，用于存储带有小数点的数字，在内存中占有64位，即8个字节，默认值0.0。
  7.char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65536，默认值为空。
  8.boolean：布尔类型，占一个字节，用户判断真或假(仅有两个值，即true、false)，默认值false。

 基本数据类型的存储原理：所有的基本数据类型不存在“引用”的概念，基本数据类型都是直接存储在内存中的内存栈上的，数据本身的值就是存储在栈空间里面，而Java语言里面八种数据类型是这种存储模型；

引用数据类型

 引用数据类型：Java语言本身不支持C++中的结构（struct）或联合（union）数据类型，它的复合数据类型一般都是通过类或接口进行构造，类提供了捆绑数据和方法的方式，同时可以针对程序外部进行信息隐藏。

 引用类型的存储原理:引用类型继承于Object类（也是引用类型）都是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，简单地讲，“引用”是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的；

 区别:基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的（不明白栈与堆的概念,点击这里）。

类型转换

自动类型转换

 自动类型转换：低优先级的数据自动会转换为高优先级的数据。
优先顺序
 如果一下两个条件都能满足，那么将一种类型的数据赋值给另一种数据变量时，将执行自动类型转换：
  1. 两种类型兼容。
  2. 目标数据类型的取值范围比源数据类型的取值范围大。
 当满足以上两个条件时，自动的“加宽转换”就可以进行。

1
2
3
例如：将一个byte值赋值给int类型的变量
	byte a = 10;
	int x= a;

 对于加宽转换，数字类型，包括整数和浮点类型都是彼此兼容的，但是，数字类型和字符类型或布尔类型是不兼容的。字符类型和布尔类型也是互相不兼容的。

强制类型转换

 强制类型转换：优先级高的数据转换为优先级低的数据。
 当需要将int型的值赋给一个byte型的变量时该怎么办？此时，只有采取被称为“变窄转换”的转换方式。因为你肯定要将源数据类型的值变小才能适合目标数据类型。在这种情况下，就必须进行强制类型转换。所谓的强制类型转换是一种显式的类型变换方式，其通用格式:(target-type) value其中，目标类型（target-type）指定了要将指定值所转换成的类型。

1
2
3
4
例如，下面的程序段将int型强制转换成byte型。
int a;
byte b;
b = (byte) a;

 当把一个浮点值赋给整数类型时，将发生一种不同的类型转换：截断。即当把浮点值赋给整数类型时，它的小数部分将会被舍去。
 例如，如果将值1.23赋给一个整数，其结果只是1，0.23被舍弃。当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为对目标类型值域取模而减少。

运算符

赋值运算符

 包括：=，+=，-=，*=，/=，%=。

1
2
3
4
5
6
例如:
	int a=2;
	a= a*b;  
	a*=b; 
	a%=b;  
	a = a%b;

算数运算符

 包括：+，-，*，/，%，++，—等，要强调的是前缀++和后缀++的区别。
后缀++：变量首先进行操作在自身进行加。
例如: int a=2; int b=a++; (a=3,b=2)
前缀++：变量自身首先加然后再进行操作。
例如: int a=2; int b=++a; (a=3,b=3)

关系运算符

 包括：==，！=，<，<=，>，>=，完成比较运算，结果为布尔类型值。

1
2
3
4
例如：		
	int a = 10;
	int b = 3;
	boolean f = a > b;

 比较a和b的值，结果为true，即f的值为true。

逻辑运算符

 包括：&，|，!，^，&&，||。
 注意区别:＆既是位运算符也是逻辑运算符，＆＆只是逻辑运算符，＆与＆＆同时作为逻辑运算符时＆＆是短路的(截断功能)，而＆并不短路。

1
2
3
例如:
	int a=6;int b=8;int c=10;int d=12;
	boolean x=++a>b++&&c++>d--;

 上面代码的结果：
a=7 b=9 c=10 d=12 x=flase

算数运算符

 算数运算符也称三目运算符。一般形式为：
表达式1？表达式2：表达式3；

1
2
3
例如:
	int x=2 ;int y=3;
	int salary=((x ==y)?2000:200);

 上面代码中因为x==y不成立，所以salary的最终值为200。

位运算符

 按位取反〜，〜01010101=10101010。(1变0 0变1)
 按位与&，11111001&10001111=1000100。(同为1时为1 )
 按位或|，11111001|10001111=11111111。（只要有一个为1就为1）
 按位异或^，11111001^10001111=01110110。（相同为0 不同为1）
 左移<<，10101011<<2=10101100。  带符号右移="">>，10101011>>2=11101010。
 无符号右移>>>，10101011>>2=00101010。

运算符优先级

运算符优先级

流程控制语句

 流程控制语句主要包括有：

  • 条件语句。
  • 循环语句。
  • 其他。

条件语句

else-if

1
2
3
4
5
6
7
if (条件表达式){
  	语句1；
}else if(条件表达式）	{
  	语句2；
} else{
	…..
}

 条件表达式的值为 boolean 值。可以有多个else if
条件表达式结果为true则执行其后{}的代码，否则判断下一个条件，如果所有的条件都不成立则执行else。
If语句可以嵌套。

switch

switch(表达式){
    case '常量值 1': 
      语句(组);
      break;
    case '常量值 2': 
      语句(组);
      break; 
    case '常量值 N': 
      语句(组);
      break;
    default:
      语句(组);
}

 switch 语句有如下规则：switch 语句中的变量类型可以是： byte、short、int 或者 char。从SE 7开始，switch 支持字符串类型当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。switch 语句可以包含一个 default 分支，default 在没有 case 语句的值和变量值相等的时候执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class SwitchOp
{
  public static void main(String args[])
    {
	  float a=9; 
	  float b=3; 
	  float result;
	  char op='+';
	  switch(op)
	  {
	  	case '+':	result=a+b;break;
	  	case '-':	result=a-b;break;
	  	case '*':	result=a*b;break;
	  	case '/':	result=a/b;break;
	  	default:	result=0;
	  }
	  System.out.println("result="+result);
	}
}

循环语句

while

1
2
3
While(condition){//先判断后执行
	System.out.println(num);
}

 判断控制表达式condition的值，当其是真时，while语句重复执行一个语句或语句块。其中条件condition可以是任何布尔表达式。只要条件表达式为真，循环体就被执行。当条件condition为假时，程序控制就传递到循环后面紧跟的语句行。若只有单个语句需要重复，大括号可以省略。

do-while

1
2
3
do {//先执行，后判断
	System.out.println(num);
} while (condition );

 先执行循环体，然后再计算条件表达式condition 。如果表达式为真，则循环继续。否则，循环结束。对所有的Java循环都一样，条件condition必须是一个布尔表达式。

for

1
2
3
4
5
6
7
8
9
10
11
for语句的执行过程
for(int i=0;i<5;i++){
	System.out.println(“this is “+i);
}
//双重循环
for(int i=0;i<5;i++){
	System.out.println(“this is “ +i);//输出5次
	for(int j=0;j<3;j++){
		 System.out.println(“this is “+j);//输出 3 * 5 次
	}	
}

 for（语句块 1 ；语句块 2；语句块 3）{}。 执行顺序 ：
 1）执行一次 语句块 1。
 2）执行语句块 2 ，若返回 true 则进入循环体；否则中断for循环。
 3）执行完循环体后，进行语句块 3 的操作。
 4）重复2，3。

其他语句

  • label:{语句块} ：用于给程序块取名字。
  • break ：语句在循环中用于立即从当前循环终止执行，结束当前循环的执行。
  • continue ：语句则是从其调用处跳至循环的开始处，结束本次循环，继续执行下一次循环， 循环体中continue 语句之后的语句将不再执行。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    //break
    int n;
    for(n=1;n<=10;n++)	{
    	if (n%2==0) break;//中断for循环
    	System.out.println("n="+n);
    }
    //continue
    int n;
    for(n=1;n<=10;n++){
    	if (n%2==0) continue;
    //中断此次循环体以后的代码段，进入语句块2
    	System.out.println("n="+n);
    }

数组

一维数组

一维数组的定义

数组的声明有多种方式：

  1. 数组类型 数组名[]；
  2. 数组类型[] 数组名；

数组类型可为Java中的任何数据类型。但是数组名，必须符合标识符定义规则。 “[]”指明该变量是一个数组类型的变量，可放到数组名后面，也可放到数组名前。

1
2
3
例如:
	int[]  arr;
	int  arr[];

一维数组的初始化

 使用new分配内存空间，并按照数组的类型，为每一个数组元素建立默任值。

1
2
3
int arr[];arr=new int[10];
或
int  arr[]=new int[10];

 也可以使用常量初始化：int[] arr = {1,2,3,4};
 []中的10表示数组的长度，即这个数组最多存放元素的个数。定义初始化数组的时候必须确定数组的长度。

一维数据的引用

 数组元素的引用格式为： 数组名[下标]

1
2
int a[]=new int[10]；
int b=a[0]+a[9];

 数组下标范围从0到9。数组下标的最小值为0，最大值为数组的长度-1，如果下标超出了范围，程序运行时将报数组越界错误：
java.lang.ArrayIndexOutOfBoundsException

一维数组的使用

class Qiuhe{
    public static void main(String args[]){
     int a[]={5,8,2,4,1,9,78};
     int min=num[0];
     for(int i=1;i<num.length;i++){
         if (min>num[i])
           min=num[i];
     }
     System.out.println("The min is:"+min);
    }
}

二维数组

二维数组的定义

二维数组可理解为数组的数组，即元素是数组的数组，定义格式为：

  1. 数组类型 数组名[][]；
  2. 数组类型[][] 数组名；
  3. 数组类型[] 数组名[]; 
    1
    2
    如： int[][]   arr;
    	int  arr[][];

二维数组的初始化

直接为每一维分配空间，例如：
int a[][]=new int[3][2];
高维开始，分别为每一维分配空间，例如：int a[][]=new int[3][];

1
2
3
a[0]=new int[2];
a[1]=new int[3];
a[2]=new int[4];

数组常量初始化，例如：

1
int a[][]={{1},{2,3},{4,5,6}};

二维数组的引用

引用格式为：
数组名[下标1][ 下标2]；
下标1，下标2分为二维数组的第一、二维下标，同一维数组一样，也可为整型常量和表达式，并且数组下标都从0开始。

1
2
3
4
5
6
int a[ ][ ]={{1,2,3},{4,5,6},{7,8,9}};
System.out.println("数组a各元素的值为：");
for(int i=0;i<4;i++){
	 for(int j=0;j<3;j++)
			System.out.println(a[i][j]+"\t");
}

二维数组的使用

  1. System类中的静态方法arraycopy() 。
    System.arraycopy(src, srcPos, dest, destPos, length);
  2. Arrays类中的方法 。
    排序方法
    sort（Object[] arrayname ）
    二分查找方法
    binarySearch(Object[] a,Object key)
    此两种方法可以用类名 + 点运算符调用。

示例：

1
2
3
4
5
6
7
8
9
10
11
int[] t={1,2,5,3};
Arrays.sort(t);
for(int i=0;i<t.length;i++){
	System.out.print(t[i]);
}
System.out.println();
int[] t2=new int[t.length];
System.arraycopy(t, 0, t2, 0, t.length);
for(int i=0;i<t2.length;i++){
	System.out.print(t2[i]);
}

字符串

什么是字符串

字符串是字符的序列，它是组织字符的基本数据结构，从某种程度上来说它是有些类似于字符的数组。在Java中，字符串被当作对象来处理。程序中需要用到的字符串可以分为两大类，一类是创建之后不会再做修改和变动的字符串常量String类；另一类是创建之后允许再做更改和变化的字符串变量StringBuffer类。

使用“”定义字符串，使用‘’定义字符。“abc”,”欢迎使用Java”都是字符串。‘a’，’b’，’c’都是字符。Java会自动为字符串常量生成一个String类的对象，所以可以直接初始化String对象，如：String s = “Hello world！”

初始化方法

创建String的一个对象并进行初始化，需要调用类String的构造方法，主要有以下创造方法：

1
2
3
4
5
6
1. String（）：创建一个空串
2. String（String value）
3. String（char value[]）
4. String（char[]，int startIndex，int numChars）
5. public String(byte[] bytes) 
6. public String(byte[] bytes,String charsetName)

操作方法

  1. 返回字符串长度，返回字符的个数public int length( )
  2. 字符串比较：
    public int compareTo(String anotherString)

  3. 判断两个字符串内容是否相同 

    1
    2
    public boolean equals(Object anObject)
    public boolean equalsIgnoreCase(String anotherString)

  4. 判断字符串是否有特定的开头或结尾 

    1
    2
    public boolean startsWith(String prefix)
    public boolean endsWith(String suffix)

  5. 字符串的检索和子串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public char charAt（int index）
    public void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
    public int indexOf(int ch)和 public int lastIndexOf(int ch)
    public int indexOf(int ch,int fromIndex)
    public int lastIndexOf(int ch,int fromIndex)
    public int indexOf(String str) 
    public int lastIndexOf(String str)
    public int indexOf(String str,int fromIndex)
    public int lastIndexOf(String str,int fromIndex)
    public String substring(int beginIndex)
    public String substring(int beginIndex,int endIndex)

  6. 字符串的修改。注意，String的修改都不会修改原字符串，修改后的字符串以新字符串的形式返回。

    1
    2
    3
    4
    5
    6
    7
    public String toLowerCase()
    public String toUpperCase() 
    public String replace(char oldChar,char newChar)
    public String replaceFirst(String rx,String replacement)
    public String replaceAll(String rx,String replacement)
    String trim()     
    public String concat(String str)

  7. 字符串类与其他类型的转换

    1
    2
    3
    4
    5
    6
    7
    8
    static String valueOf(char data[])
    static String valueOf(char data[],int offset,int count)
    static String valueOf(boolean b)
    static String valueOf(char c)
    static String valueOf(int i) 
    static String valueOf(long l)
    static String valueOf(float f)
    static String valueOf(double d)

字符串的比较

equals方法比较两个字符串的内容是否相同。
== 比较两个字符串是否是同一个字符串。
简单来理解是：equals比较的是值是否相同，==比较的是地址是否相同。

StringBuffer和StringBuilder

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用StringBuffer 类。

StringBuffer 上的主要操作是 append方法，能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。
append 方法始终将这些字符添加到缓冲区的末端。所以，如果程序中需要经常修改某个字符串，不能使用String，应该用StringBuffer或者StringBuilder。

方法

方法是什么

方法是一段可以重复调用的代码块。这个代码块实现了某一个功能，当我们的程序中需要这个功能的时候，调用这个方法即可，不需要重复书写这个功能的代码。

方法的定义格式

[public|private|protect] [static] 返回值类型 方法名称(参数列表){
    方法体
    [return 返回值;]
}

方法说明：

  1. [public|private|protect] [static]第一个参数代表方法的权限,不写就是默认权限。权限代表的意义如下图：

    第二个参数写上代表这个方法是静态的，不写代表它是非静态的。
  2. 返回值类型：表示通过调用方法可以得到的结果类型。如果返回类型为void,表示这个方法完成功能，但是不会返回值，如果返回类型是某个具体的数据类型，表示这个方法完成功能并返回一个具体值，方法体最后
    应该使用return语句返回这个值。
  3. 方法名称：表示方法的名字，应该符合标识符规范(首个单词首字母小写，其余字母首字母大写)
  4. 参数列表：表示这个方法要完成功能需要参照的数据，定义方法时称作形参，调用方法时需要给出具体的参数值称作实参。实参与形参一一对应。一个方法可以有多个参数，用逗号隔开。如参数类型1 参数名字1，参数类型2 参数名字2……
  5. 方法体:放在{}中，是方法实现功能的代码块。

执行顺序

定义一个方法在主方法中调用：

    public class Test{
        public static void main(String[] args){
            printInfo(); //调用 1
            printInfo(); //调用 2 
            System.out.println(“aowin”); //3
        }
        public static void printInfo(){
            System.out.print(“one”);  //4
             System.out.print("two");  //5
        }
    }

我们来简单分析一下程序的执行顺序：
先执行主函数 执行到1的位置的时候调用了printInfo()方法，此时程序调到4开始执行，控制台打印出one,然后再执行5控制台打印two。然后再回到了主函数，开始执行2，但是2又调用了printInfo()方法所有有执行了4-5，最后又回到主函数执行3

-------------本文结束感谢您的阅读-------------