java基础内容
基础语法
注释
//单行注释 双斜杠开头
//输出一个helloworld
System.out.println("Hello world");
//多行注释：可以注释一段文字
/*我是多行注释
666
*/
标识符
标识符注意点
-
所有标识符都应该以字母和美元符（$）或者下划线开头
-
首字母之后可以是字母，字符，下划线，美元符任意组合
-
不能使用关键字命名
-
标识符是大小写敏感的
-
可以中文命名，但不推荐很low
强类型语言
要求变量的使用要严格符合规定，所有的变量都必须先定义后使用
java的数据类型分为两大类
基本类型
整数类型
-
byte
-
short
-
int
-
long
浮点型类型
-
float
-
double
字符型类型
char
Boolean类型
True False
引用类型
除了基本数据类型以外的类型，都是引用数据类型
-
类
-
接口
-
数组
//八大数据类型
//整数
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 换行
类型转换
注意点
-
不能对布尔值进行转换
-
不能把对象类型转换为不相干的类型
-
在把高容量转换到低容量的时候，强制转换
-
转换的时候可能存在内存溢出，或者精度问题
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
变量
变量可以变化的量，其要素包括变量名，变量类型，变量作用域。
注意事项
-
每个变量都要有类型，可以是基本数据类型，或者引用类型
-
变量名是合法的标识符
-
变量声明后面必须有分号结尾
变量又包括，类变量，实例变量，局部变量
//类变量 会从属于这个类，会随着这个类同时出现同时消失
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():
-
一定要读取到有效字符后才可以结束输入
-
对输入有效字符之前遇到的空白，next()方法会自动将其去掉
-
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
-
next()不能得到带有空格的字符串
nextLine():
-
以Enter为结束符，也就是nextLine()方法返回的是输入回车之前的所有字符
-
可以获得空格
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的区别
-
while先判断后执行。do while 是先执行后判断
-
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;
}
方法的重载就是在一个类中，有相同的函数名称，但形参不同的函数
方法重载的规则
-
方法名称必须相同
-
参数列表必须不同（个数不同，或类型不同，参数排列顺序不同）
-
方法返回值可以相同也可以不相同
可变参数
-
从1.5开始，java支持传递同类型的可变参数给一个方法
-
在方法声明中，在指定参数类型后加一个省略号（...）
-
一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何的普通参数必须在它之前声明
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){