Java基础知识

1.1规范

1. java中一切都是对象，对象是类的实例，数据和函数都封装在类里
2. class生命一个类，源程序文件名和public的类名相同
3. 区分大小写，类名大写开头
4. 数据变量称为类的“成员变量”，函数称为类的“成员方法”
5. 必须含有main()方法,必须由public,static,void修饰，只有一个

1.2标识符

1. 可以由字母，数字，下划线，$组成，开头不能是数字
2. 不能用java保留关键字
3. 不能包含空格

1.3数据类型及变量

java是强类型语言，使用变量前必须先声明

八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
  例子：byte a = 100，byte b = -50。

short

• short的数据类型是16位、有符号的以二进制补码表示的整数
• 最小值-32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• 是int型所占空间的二分之一
• 默认值0
• short s=1000 short r=-1000

int

• 32位、有符号的二进制补码表示的整数
• 最小值-2^31
• 最大值2^31 - 1
• 一般整数默认位int型
• 默认值0

long

• 64位、有符号的二进制补码表示的整数
• 最小值-2^63
• 最大值2^63 - 1
• 用于较大的整数上
• 默认值0L
• long a = 10000L

float

• 单精度、32位、符合IEEE 754标准的浮点数
• 存储大型浮点数时可节省空间
• 默认值0.0f
• 不能表示精确地值
• float f=222.2f

double

• 双精度、64位、IEEE标准的浮点数
• 默认类型为double
• 不能表示精确地值
• 默认值0.0d

boolean

• 表示一位的信息
• true false
• 默认值false

char

• 单一的16位Unicode字符
• 最小值\u0000(十进制为0)
• 最大值\uffff(65535)
• 可以储存任何字符
• 两个字节（16个二进制位）为一个字符，用单引号赋值

引用类型

• 引用类型指向一个对象，指向对象的变量是引用变量，变量一旦声明后，类型就不能被改变了
• 对象、数组都是
• 默认值null

常量
常量在运行时不能被修改
使用final来修饰
通常使用大写字母表示

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制

\n 换行 (0x0a)
\r 回车 (0x0d)
\f 换页符(0x0c)
\b 退格 (0x08)
\0 空字符 (0x0)
\s 空格 (0x20)
\t 制表符
" 双引号
’ 单引号
\ 反斜杠
\ddd 八进制字符 (ddd)
\uxxxx 16进制Unicode字符 (xxxx)

1.4数据类型转换

自动转换

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double 

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如:
short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

• 不能对boolean类型进行类型转换
• 不能把对象类型转换成不相关类的对象
• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换
• 转换过程中可能导致溢出或损失精度
• 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

int i =128;   
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

强制装换
大数据————>小数据

• 条件是转换的数据类型必须是兼容的。
• (type)value type是要强制类型转换后的数据类型

float f=1.5f;
Float F=new Float(f);
double d=F.doubleValue();

Boolean(boolean value)
Character(cahr value)
Integer(int value)
Long(long value)
Float(float value)
Double(double value)
…
字符串相关的类型转换
1

• X.toString()
• X+""
• String.valueOf(X)

2字符串作为参数值，向其他类型转换

String s="12";
byte b=Byte.parseByte(s);
short t=Short.parseShort(s);
int i=Interget.parseInt(s);
.......
parseXXX为静态方法，通过类名.静态方法（参数）直接使用

3日期类转换
Date(int year,int month,in date);
Date(int year,int month,int date,int hrs,int min,int sec);

Date date = new Date();
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));

1.5表达式

• 算术运算符

+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
--	自减: 操作数的值减少1
------------------------------------------------------------------------------------------------
1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，
而自增自减运算符是一个操作数。
int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2
------------------------------------------------------------------------------------------------

2、前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
------------------------------------------------------------------------------------------------
3、后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 
public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}
自增运算符前缀运算后a=6，x=12
自增运算符后缀运算后b=6，y=10

• 关系运算符

==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
> 	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
< 	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

• 逻辑运算符

&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

• 赋值运算符

=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C/A
(％)=取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =左移位赋值运算符	C << = 2等价于C = C << 2
>> =右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

• 其他运算符

三元运算符
x = (expression) ? value1:value2

• Java运算符优先级

后缀	() [] . (点操作符)	左到右
一元	expr++ expr--	从左到右
一元	++expr --expr + - ～ ！	从右到左
乘性 	* /％	左到右
加性 	+ -	左到右
移位 	>> >>>  << 	左到右
关系 	> >= < <= 	左到右
相等 	==  !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到右

1.6常用函数

字符串函数

• String.charAt() 方法返回指定索引处的char值。索引范围是从0到length() - 1。对于数组索引，序列的第一个char值是在索引为0，索引1，依此类推

public class Test {
    public static void main(String[] args) {
        String s ="abc";
        System.out.println(s.charAt(1));
    }
}

• indexOf

public int indexOf(int ch): 
返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

public int indexOf(int ch, int fromIndex): 
返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

int indexOf(String str): 
返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

int indexOf(String str, int fromIndex): 
返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

• lastIndexOf()
  查找最后一个匹配的位置

• String replace()

在String类中replace(char oldChar,char newChar)是把字符串中的oldChar替换为newChar，其中oldChar的长度要和newChar的长度相同。

         String str3="abcd";
         String str4=str3.replace("ab","ff");
         System.out.println(str4);
		输出结果为：
		ffcd

• String.substring(int beginIndex)

一个是从指定位置截取到字符串结尾，另一个是截取指定范围的内容
1. substring(int beginIndex) 形式
此方式用于提取从索引位置开始至结尾处的字符串部分。
调用时，括号中是需要提取字符串的开始位置，方法的返回值是提取的字符串。
String str = "我爱 Java 编程";
String result = str.substring(3);
System.out.println(result);    // 输出：Java 编程

2. substring(int beginIndex，int endIndex) 形式[)
beginIndex 表示截取的起始索引，截取的字符串中包括起始索引对应的字符；
endIndex 表示结束索引，截取的字符串中不包括结束索引对应的字符，如果不指定 endIndex，
则表示截取到目标字符串末尾。
该方法用于提取位置 beginIndex 和位置 endIndex 位置之间的字符串部分。

```java
public static void main(String[] args) {
    String day = "Today is Monday";    //原始字符串
    System.out.println("substring(0)结果："+day.substring(0));
    System.out.println("substring(2)结果："+day.substring(2));
    System.out.println("substring(10)结果："+day.substring(10));
    System.out.println("substring(2,10)结果："+day.substring(2,10));
    System.out.println("substring(0,5)结果："+day.substring(0,5));
}


输出：
substring(0)结果：Today is Monday
substring(2)结果：day is Monday
substring(10)结果：onday
substring(2,10)结果：day is M
substring(0,5)结果：Today

• split(String regex, int limit)

split() 方法根据匹配给定的正则表达式来拆分字符串。

注意： . 、 $、 | 和 * 等转义字符，必须得加 \。

注意：多个分隔符，可以用 | 作为连字符。

public String[] split(String regex, int limit)

参数：
regex – 正则表达式分隔符。
limit – 分割的份数。
返回值:
字符串数组。

• equlars()
  判断字符串是否相等
• length 字符串长度
• toLowerCase &&toUpperCase 大小写转换
• trim() 去除串头串尾的空格
• compareTo 字符串比较
• concat 字符串连接函数（不改变原值）
• startsWith（） 是否以（）为开头
• endsWith() 是否以（）为结尾
• reverse() 颠倒字符串所有内容

1.8类，对象

类似于模板，里面定义了一些变量和方法。

[修饰符]class 类名 [extends 父类][implements 接口]{
	[修饰符]变量类型 变量名;
	[修饰符]变量类型 变量名=初始值；
	[修饰符]返回值类型 方法名（参数1，参数2....）{}
}

车就是一个类,里面有很多变量和方法如颜色，品牌，型号，动作等
下图，新建对象后再给生成的车的对象设置颜色等变量。

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

public class Dog {
    String breed;//实例变量
    int size;
    private String colour;
    int age;
 	static int n;//类变量
 
 	public Dog(){//构造方法
 		super;
 	}
 	
    void eat() {
     
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    	String nm='abc';//局部变量，在类的方法体内声明
    }
    static String getName(){//类方法  用类名.方法名 调用
		return n;
	}
}

创建对象

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字 new 来创建一个对象。
• 初始化：使用 new 创建对象时，会调用构造方法初始化对象。

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

1.9 成员变量与局部变量

成员变量就是类里面的方法，作用于整个类
局部变量是类里面方法里的变量，只在该方法里起作用

1.10实例变量与静态变量

成员变量又可以分为实例变量和静态变量（类变量）
类变量不管创建多少个对象，他只有一个，能被所有的对象更改
静态初始化：
在类被装入内存后只执行一次，用于初始化

1.11静态方法与实例方法

静态方法也成类方法,用static修饰，调用前必须创建实例
用类名.方法名 调用
实例方法必须通过实例才能调用，可以对当前对象的实例变量进行操作，而且也可以访问类变量。
实例方法是属于类的某个对象的

1.12构造方法

是一种特殊的方法，它是一个与类同名的方法
当用类新建对象开辟内存空间时自动执行（当类实例化一个对象时会自动调用构造方法）
构造方法和其他方法一样也可以重载
注意

• 构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有
• 一个类中可以有多个构造方法，参数必须有区别
• 类中必定有构造方法，若不写，系统自动添加无参构造方法
• 接口不允许被实例化，所以接口中没有构造方法。
• 不能被static、final、synchronized、abstract和native修饰
• 分为两种：无参构造方法 有参构造方法
  用new建立对象实例时，java会自动匹配寻找匹配的构造方法，这就叫做方法的重载

public Person(String name,int age,double weight){
	super();
	this.name=name;
	this.age=age;
	this.weight=weight;

}

super代表调用父类的构造方法
this.name=name;表示来自参数列表的name值赋值给本对象（this代表本对象）的成员变量name

单个构造函数方法：

多个构造函数方法：

构造方法创建后，原来默认的隐式构造方法消失

1.13继承和抽象类

类与类之间的归属关系
子类可以通过继承复用父类中的代码，并且扩展自己的代码。