基础语法

注释

//单行注释  双斜杠开头
//输出一个helloworld
System.out.println("Hello world");
//多行注释：可以注释一段文字
/*我是多行注释
666
*/


标识符

标识符注意点

  2. 所有标识符都应该以字母和美元符（$）或者下划线开头
  3. 首字母之后可以是字母，字符，下划线，美元符任意组合
  4. 不能使用关键字命名
  5. 标识符是大小写敏感的
  6. 可以中文命名，但不推荐很low

数据类型

强类型语言

要求变量的使用要严格符合规定，所有的变量都必须先定义后使用

 

java的数据类型分为两大类

基本类型

整数类型
  2. byte
  3. short
  4. int
  5. long
浮点型类型
  2. float
  3. double
字符型类型

char

Boolean类型

True False

引用类型

除了基本数据类型以外的类型，都是引用数据类型

  2. 类
  3. 接口
  4. 数组
//八大数据类型
//整数
int num=20; //最常用
byte num1=20;
short num2=30;
long num3=30L;//Long类型要在数字后面加个L
//小数
float num4=50.1F;//float类型要在数字后面加个F
double num5=3.145664964;
//字符
char name='a';
//字符串String 不是关键字，是类
//String name="海森";
//布尔类型 是非
boolean flag=true;
//boolean flag=false;


 

//整数扩展：  进制 二进制0b  十进制  八进制0  十六进制0x
int i=10;
int i1=0b1;
int i2=010; //八进制0
int i3=0x10;//十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
//浮点数扩展？  银行业务怎么表示  ？
//BigDecimal 数字工具类
//float 有限 离散 舍入误差 接近但不等于
//double
//最好不要使用浮点数比较
float f=0.1f;//0.1
double d=1.0/10;//0.1
System.out.println(f==d); //false
float f1=231313131313131f;
double d1=f1+1;
System.out.println(f1==d1); //true
//字符扩展
char c1='a';
char c2='中';
System.out.println(c1);
System.out.println((int)c1);//强制转换 //97
System.out.println(c1);
System.out.println((int)c1);//强制转换 //20013
//所有的字符本质还是数字
//编码 Unicode 表：（97=a 65=A）
//转义字符
// \t制表符
// \n 换行


类型转换

注意点

  2. 不能对布尔值进行转换
  3. 不能把对象类型转换为不相干的类型
  4. 在把高容量转换到低容量的时候，强制转换
  5. 转换的时候可能存在内存溢出，或者精度问题
int i=128;
byte b=(byte)i; //内存溢出
//强制转换  （类型）变量名  高--低
System.out.println(i);//128
System.out.println(b);//-128
//自动转换  低--高
int i1=128;
double b1=i1; //内存溢出
System.out.println(i1);//128
System.out.println(b1);//128.0
/*
注意点：
1.不能对布尔在进行转换
2.不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题
*/
System.out.println("============");
System.out.println((int)23.7);//23
System.out.println((int)-45.89f);//-45
System.out.println("============");
char c='a';
int d=c+1;
System.out.println(d);//98
System.out.println((char)d);//b
System.out.println("============");
//操作比较大的数时候，注意溢出问题
//jdk7 新特性可以在数字之间加上下划线
int momey =10_0000_0000;
int years=20;
int total=momey*years;
// System.out.println(total);//-1474836480,计算溢出了
long total1=momey*years;
// System.out.println(total1);//-1474836480 //默认是int 转换前就已经出现问题了
long total2=momey*((long)years);
System.out.println(total2); //20000000000 先把一个数转换为long


变量

变量可以变化的量，其要素包括变量名，变量类型，变量作用域。

注意事项

  2. 每个变量都要有类型，可以是基本数据类型，或者引用类型
  3. 变量名是合法的标识符
  4. 变量声明后面必须有分号结尾

变量又包括，类变量，实例变量，局部变量

//类变量 会从属于这个类，会随着这个类同时出现同时消失
static double salary=100;
//实例变量：从属于对象；如果不进行初始化，这个类型的默认值是0 0.0
//布尔值是false
//除了基本类型其余的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量  必须声明和给初始值
int i=10;
System.out.println(i);
Demo04 demo04 = new Demo04();
System.out.println(demo04.age);
System.out.println(demo04.name);
System.out.println(salary);
}


常量

初始化后不能改变的值，不会变动的值

final关键字

//修饰符不存在前后顺序
static final double PI=3.14;
public static void main(String[] args) {
System.out.println(PI);
}


运算符

//二元运算符
// Ctrl +d :复制当前行到下一行
int a=10;
int b=20;
int c=25;
int d=25;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b);
long l=123123123456123l;
int i=123;
short s=10;
byte b1=8;
System.out.println(l+i+s+b1); //Long
System.out.println(i+s+b1);//Int
System.out.println(s+b1);//Int
//结论如果运算里面有long那么结果就是lang类型，其他的也同理
//关系运算符的返回结果：正确 和错误 true false
int a=10;
int b=20;
int c=21;
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
System.out.println(c%a);


关系运算符的返回结果：正确 和错误 true false

// ++ -- 一元运算符
int a=3;
int b=a++; //执行完这行代码，先给b赋值，再自增
int c=++a; //执行完这行代码，先自增，再给c赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 很多运算会使用一些工具类来操作
double pow = Math.pow(2, 3);
System.out.println(pow);


++ -- 一元运算符

// 与或非运算
boolean a=true;
boolean b=false;
System.out.println("a && b:"+(a&&b));//逻辑与运算，两个变量为真，结果才为true
System.out.println("a || b:"+(a||b));//逻辑或运算，一个变量为真，结果才为true
System.out.println("!(a&&b):"+!(a&&b));//如果是真，则变为假，如果是假则为真
//短路运算
int c=4;
boolean d=(c<4)&&(c++<4);
System.out.println(c);
System.out.println(d);


与或非运算

int a=20;
int b=10;
//字符串连接符 + ，string
System.out.println(" "+a+b);
System.out.println(a+b+" ");


字符串连接符

//三元运算符
//x?y:z   如果x==true 则结果为y 否则为z
int score=50;
String type=score<60 ? "不及格":"及格";
System.out.println(type);


三元运算符

包机制

javadoc

package base;
/**
* @author haisen
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
* @author haisen
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
}


 

Scanner用户交互

next():

  2. 一定要读取到有效字符后才可以结束输入
  3. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  4. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  5. next()不能得到带有空格的字符串

nextLine():

  2. 以Enter为结束符，也就是nextLine()方法返回的是输入回车之前的所有字符
  3. 可以获得空格

 

public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘的数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收");
if (scanner.hasNext()){
System.out.println("next方式接收");
String str=scanner.next();
System.out.println("输出的内容是"+str);
}
//凡是io流的类如果不关闭会一直占用资源，要养成良好的习惯
scanner.close();
}
public static void main(String[] args) {
//从键盘中获取数据
Scanner scanner = new Scanner(System.in);
//判断用户还有没有输入
if (scanner.hasNextLine()){
String str=scanner.nextLine();
System.out.println("你输入的数据是"+str);
}
scanner.close();
}
public static void main(String[] args) {
//我们可以输入多个数据，平求其总数和平均值，每输入一个数字回车确认，通过输入非数字来结束并输出结果
Scanner scanner=new Scanner(System.in);
//和
double sum=0;
//计算了多少个数字
int m=0;
//通过循环判断是否还有输入，并在里面对每一次数据进行求和统计
while(scanner.hasNextDouble()){
double x=scanner.nextDouble();
m=m+1;
sum=sum+x;
System.out.println("你输入了第"+m+"个数据，当前结果是："+sum);
}
System.out.println("一个有"+m+"数据 数据和是"+sum);
System.out.println(+m+"个数据 平均值是"+sum/m);
scanner.close();
}


if选择结构

1. if语句至多有一个else语句，else语句必须在所有的else if 语句之后

2. if语句有若干个else if 语句，他们必须在 else语句之前

3.一旦其中一个else if 语句检测为true，其他的else if 以及 else 语句将跳过执行

public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入成绩");
int score = scanner.nextInt();
if (score==100){
System.out.println("成绩满分");
}else if (score<100 && score>=90){
System.out.println("A级");
}else if (score<100 && score>=90){
System.out.println("B级");
}else if (score<90 && score>=80){
System.out.println("C级");
}else if (score<80 && score>=70){
System.out.println("D级");
}else if (score<70 && score>=60){
System.out.println("E级");
}else if (score<60 && score>=0){
System.out.println("不及格");
}else {
System.out.println("成绩不合法");
}
scanner.close();
}


 

switch选择

public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
//case 穿透  switch 匹配一个具体的值
char c='A';
switch(c){
case 'A':
System.out.println("A级");
break;
case 'B':
System.out.println("B级");
break;
case 'C':
System.out.println("C级");
break;
default:
System.out.println("未知等级");
}
scanner.close();
}
public static void main(String[] args) {
//jdk新特性，表达式结果可以是字符串！！！
//字符的本质还是数字
String name="海森";
switch(name){
case "海森":
System.out.println("名字是海森");
break;
case "大海":
System.out.println("名字是大海");
break;
default:
System.out.println("名字不对口");
}
}


While循环

public static void main(String[] args) {
int i=0;
int sum=0;
while(i<=100){
sum=sum+i;
i++;
}
System.out.println(sum);
}


while和do while的区别

  2. while先判断后执行。do while 是先执行后判断
  3. do while总是保证循环体会被执行至少一次，这是他们只要的区别

for循环

for循环说明：最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后，检测布尔表达式的值，如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。再次检测布尔表达式，循环执行上面的过程。

//计算1到100的奇数和和偶数和
public static void main(String[] args) {
int oddsum=0;
int evensum=0;
for (int i = 0; i <= 100; i++) {
if ((i%2)!=0){
oddsum+=i;
}else{
evensum+=i;
}
}
System.out.println("奇数和"+oddsum);
System.out.println("偶数和"+evensum);
}
public static void main(String[] args) {
//for循环输出1-1000之间能被5整除的数，并且每行输出三个
for (int i = 1; i <= 1000; i++) {
if ((i%5)==0){
System.out.print(i+"\t");
}
if (i%(3*5)==0){
System.out.println();
}
}
}
public static void main(String[] args) {
//打印九九乘法表
for (int i = 1; i <= 9; i++) {
for (int j=1;j<=i;j++){
System.out.print(i+"乘于"+j+"等于"+i*j+"\t");
}
System.out.println();
}
}


break在任何循环语句的主体部分，均可用break控制循环的过程，break用于强行退出循环，不执行循环中剩余的语句。（break也在switch中使用）

public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
if (i==30){
break;
}
System.out.println(i);
}
}


 

continue语句用在循环体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
if (i%10==0){
continue;
}
System.out.print(i);
}
}
//打印三角形
for (int i = 1; i <= 5; i++) {
for (int j=5;j>=i;j--){
System.out.print("!");
}
for (int j=1;j<=i;j++){
System.out.print("*");
}
for (int j=1;j<i;j++){
System.out.print("*");
}
System.out.println();
}
}


方法

public static void main(String[] args) {
int max = max(10, 10);
System.out.println(max);
}
//比大小
public static int max(int num1,int num2){
int result=0;
if (num1==num2){
System.out.println("num1=num2");
return 0;
}
if (num1>num2){
result=num1;
}else {
result=num2;
}
return result;
}


方法的重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法重载的规则

  2. 方法名称必须相同
  3. 参数列表必须不同（个数不同，或类型不同，参数排列顺序不同）
  4. 方法返回值可以相同也可以不相同

可变参数

  2. 从1.5开始，java支持传递同类型的可变参数给一个方法
  3. 在方法声明中，在指定参数类型后加一个省略号（...）
  4. 一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何的普通参数必须在它之前声明
public static void main(String[] args) {
Demo04 demo04 = new Demo04();
demo04.test(10,20,30,40);
}
public  void test(int... nums){
System.out.println(nums[0]);
System.out.println(nums[1]);
System.out.println(nums[2]);
System.out.println(nums[3]);
}


递归

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

 

计算机

import java.util.Scanner;
public class JiSuanQi {
static double num1;
static double num2;
static String c;
static Scanner scanner;
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
while(true){
scanner = new Scanner(System.in);
System.out.println("请输入第一个数：");
if (scanner.hasNextDouble()){
num1=scanner.nextDouble();
break;
}else{
System.out.println("你输入不是数字");
continue;
}
}
System.out.println("请输入要进行操作的符号：");
c=scanner.next();
while(true){
System.out.println("请输入第二个数：");
scanner = new Scanner(System.in);
if (scanner.hasNextDouble()){
num2=scanner.nextDouble();
break;
}else{
System.out.println("你输入不是数字");
continue;
}
}
switch(c){
case "+":
double add = add(num1, num2);
System.out.println("结果是"+add);
break;
case "-":
double reduce = reduce(num1, num2);
System.out.println("结果是"+reduce);
break;
case "*":
double ride = ride(num1, num2);
System.out.println("结果是"+ride);
break;
case "/":
double except = except(num1, num2);
System.out.println("结果是"+except);
break;
default:
System.out.println("非法符号");
break;
}
scanner.close();
}
public static double add(double num1,double num2){
return num1+num2;
}
public static double reduce(double num1,double num2){
return