一、注释
1.单行注释://注释内容
2.多行注释:/注释内容 /
3.文档注释:/注释内容 */
================================================
二、数据类型
1.基本数据类型:整数型、小数型、字符型、布尔型。
数据类型范围从小到大:byte<char<short<int<long<float<double
*自动类型转化,范围小的数据类型向范围大的数据类型转化时使用;
*强制类型转化,范围大的数据类型向范围小的数据类型转化时使用;
整数型:
(1).byte数据类型是8位、有符号的,以二进制补码表示的整数;
最小值是 -128(-2^7);
最大值是 127(2^7-1);
默认值是 0;
例子:byte a = 100,byte b = -50
(2).short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768(-2^15);
最大值是 32767(2^15 - 1);
例子:short s = 1000,short r = -20000。
(3).int 数据类型是32位、有符号的以二进制补码表示的整数;
最小值是 -2,147,483,648(-2^31);
最大值是 2,147,483,647(2^31 - 1);
一般地整型变量默认为 int 类型;
默认值是 0 ;
例子:int a = 100000, int b = -200000。
(4).long 数据类型是 64 位、有符号的以二进制补码表示的整数;
最小值是 -9,223,372,036,854,775,808(-2^63);
最大值是 9,223,372,036,854,775,807(2^63 -1);
这种类型主要使用在需要比较大整数的系统上;
默认值是 0L;
例子: long a = 100000L,Long b = -200000L。
"L"理论上不分大小写,但是若写成"l"容易与数字"1"混淆,不容易分辩。所以最好大写。
小数型:
(1).float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;
默认值是 0.0f;
浮点数不能用来表示精确的值,如货币;
例子:float f1 = 234.5f。
(2).double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;
浮点数的默认类型为double类型;
double类型同样不能表示精确的值,如货币;
默认值是 0.0d;
例子:double d1 = 123.4。
字符型:
char类型是一个单一的 16 位 Unicode 字符;
最小值是 \u0000(即为0);
最大值是 \uffff(即为65,535);
char 数据类型可以储存任何字符;
例子:char letter = 'A';。
布尔型:
boolean数据类型表示一位的信息;
只有两个取值:true 和 false;
这种类型只作为一种标志来记录 true/false 情况;
默认值是 false;
例子:boolean one = true。
2.引用数据类型:数组、类、接口。
====================
三、变量
1.定义变量的语法格式:
数据类型 变量名 = 数据值
int a = 100;
创建引用类型变量格式:
类型 变量名 = new 类型();
引用变量功能:
变量名.功能名字();
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String i = sc.next();
System.out.println(i);
}
}
2.Java语言支持的变量类型有:
类变量:独立于方法之外的变量,用 static 修饰。
实例变量:独立于方法之外的变量,不过没有 static 修饰。
局部变量:类的方法中的变量
(1)类变量(静态变量)
类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。
无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
静态变量在第一次被访问时创建,在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
静态变量可以通过:ClassName.VariableName的方式访问。
类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。
(2)实例变量
实例变量声明在一个类中,但在方法、构造方法和语句块之外;
当一个对象被实例化之后,每个实例变量的值就跟着确定;
实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
实例变量可以声明在使用前或者使用后;
访问修饰符可以修饰实例变量;
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。
(3)局部变量
局部变量声明在方法、构造方法或者语句块中;
局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
访问修饰符不能用于局部变量;
局部变量只在声明它的方法、构造方法或者语句块中可见;
局部变量是在栈上分配的。
局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。
===============================================
四、运算符
1.算术运算符
2.自增自减运算符
(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--): 先进行表达式运算,再进行自增或者自减运算
3.关系运算符
4.位运算符
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
5.逻辑运算符
6.短路逻辑运算符
当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了。
public class LuoJi{
public static void main(String[] args){
int a = 5;//定义一个变量;
boolean b = (a<4)&&(a++<10);
System.out.println("使用短路逻辑运算符的结果为"+b);
System.out.println("a的结果为"+a);
}
}
7.赋值运算符
8.三元运算符
public class Test {
public static void main(String[] args){
int a , b;
a = 10;
// 如果 a 等于 1 成立,则设置 b 为 20,否则为 30
b = (a == 1) ? 20 : 30;
System.out.println( "Value of b is : " + b );
//如果 a 等于 10 成立,则设置 b 为 20,否则为 30
b = (a == 10) ? 20 : 30;
System.out.println( "Value of b is : " + b );
}
}
9.运算符优先级
==============================================
五、字符串
- 创建字符串:String a = "我爱java";
*String 类是不可改变的,所以你一旦创建了 String 对象,那它的值就无法改变了
2.字符串长度:String 类的一个访问器方法是 length() 方法,它返回字符串对象包含的字符数。
public class StringDemo {
public static void main(String args[]) {
String site = "www.baidu.com";
int len = site.length();
System.out.println( "字符串长度 : " + len );
}
}
3.连接字符串: " + "
public class StringDemo {
public static void main(String args[]) {
String string1 = "百度网址:";
System.out.println("1、" + string1 + "www.baidu.com");
}
}
===============================================
六、输入输出
输入:
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String i = sc.next();
System.out.println(i);
}
}
next() 与 nextLine() 区别
next():不能得到带有空格的字符串。
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白,next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
nextLine():
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
输出:
System.out.println();
===================================================
七、控制流程
1.复合语句
Java语言的复合语句是以整个块区为单位的语句,又称块语句。复合语句由“{”开始,“}”结束。
2.条件语句
(1).if 条件语句
格式:if(条件){
if语句的执行体
}
条件:结果必须是布尔型。1==1 true||false
执行体:当if中的条件为true时,执行大括号中的执行体;当if中的条件为false时,什么也不做
(2). if...else语句
格式:if(判断条件){
执行语句1
...
}
else{
执行语句2
...
}
(3).if else if else语句
格式:if(条件){执行体
}else if{ 执行体
}
else if{ 执行体
}
else{ 执行体
}
(4).switch多分支语句
格式:
switch(表达式){
case 常量1:
要执行的语句 ;
break;
case 常量2:
要执行的语句 ;
break;
default:
要执行的语句;
break;
}
执行流程:表达式和case后面的常量比较,和哪个case后的常量相同,就执行哪个case后面的程序,遇到break就全结束。如果都不匹配就执行default后面的程序。
case的穿透性:case后面没有break,程序就会一直向下穿透。
3.循环语句
(1).while循环
格式:while(条件){
循环体
}
条件:当条件是true,就执行循环体,执行完循环体后程序再次执行while中的条件,如果还是true,继续执行循环体,直到条件是false的时候,循环就结束。
(2).do...while循环
格式:do{
循环体
} while(条件);
特点:无条件先执行一次
(3).for循环
格式:for(初始化变量;条件;增量){
循环体
}
初始化变量:定义变量,作用,控制循环的次数
条件:当条件时true,执行循环体,条件时false,结束循环。
(4).for循环嵌套
格式:for(){
for(){
}
}
总的循环次数 = 内循环次数 * 外循环次数
public class ForFor {
public static void main(String[] args) {
for(int i = 0;i<6;i++) {
for(int j = 0;j<7;j++) {
System.out.print("* ");
}
System.out.println();
}
}
}
外循环控制的时行数;
内循环控制的是列数。
4.跳转语句(break,continue)
1.break关键字:作用于循环中,终止循环的作用
2.continue关键字:在循环中,终止本次循环,开始下一次循环
例:20以内奇数
public class ContinueDemo {
public static void main(String[] args) {
for(int i=0;i<20;i++) {
if(i%2==0){
continue;
}
System.out.println(i);
}
}
}
(3).return语句
return语句可以从一个方法返回,并把控制权交给调用它的语句。
public void getName() {
return name;
}
================================================
八、数组
定义数组容器:定义数组容器,要素,强制数据类型的语言必须有数据类型,大小,就是存储数据的个数。
数据类型:数组中存储元素的数据类型
[ ]:表示数组的意思
变量名:自定义标识符
数组是一个容器:存储到数组的每个元素,都有自己的自动编号
访问数组存储的元素,必须依赖与索引
公式:数组名[索引]
Java提供一个属性,操作索引的数组的一个属性,就是数组的长度,属性名字length。
使用属性:数组名.length
数组的最小索引是0,最大索引数组.length-1
数组的三个定义方式:
(1).数组类型[ ] 变量名 = new 数组类型[ ]{元素1,元素2,元素3};
注意事项:new后面的中括号中,不允许写任何内容,写了就编译失败。
(2).数组类型[ ] 变量名 = {元素1,元素2,元素3};
(3).数据类型[ ] 变量名 = new 数据类型[存储元素的个数];
数组遍历:
public class ArrayDemo_1 {
public static void main(String[] args) {
int[] arr = {12,16,4,5,15,9};
for(int i = 0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
数组中两个异常:
(1).数组的索引越界异常:java.lang.ArrayIndexOutOfBoundsException
(2).空指针异常:java.lang.NullPointerException
二维数组:数组中的数组,数组里面存储的还是数组
格式:int[ ][ ] arr = new int[3][4];
[3]:表示二维数组中,有三个一维数组
[4]:表示三个一维数组中,每个数组的长度是4
二维数组定义方式:
int[ ][ ] arr = {{1,4},{3,6,8},{0,9,8}};
二维数组的遍历:
public class ArrayArrayDemo {
public static void main(String[] args) {
int[ ][ ] arr = {{1,2,3},{4,5,},{6,7,8,9},{0}};
for(int i = 0;i<arr.length;i++) {
for(int j =0;j<arr[i].length;j++) {
System.out.print(arr[i][j]);
}
System.out.println();
}
}
}