Java基础-语法

语法基础

转义字符

public static void main(String[] args) {
   // \t制表符对齐
   System.out.println("a\tb\tc");
   //\n换行
   System.out.println("jack\nsminth\nmary\n");
   //\\
   System.out.println("c:\\windows\\java");
   //\"打印双引号
   System.out.println("he says:\"go fighting\"");
   //\r回车
   System.out.println("world\rhello");
}

编译过程：
.java->.class(多个最终要执行的字节码文件）
javac+源文件名，进行编译

运行过程：
java+类名运行

java命令运行启动JVM,并启动类加载器ClassLoader,
Classloader搜索.class文件，并将其装载到JVM中，JVM将
.class文件结实成二进制数据，操作系统运行二进制文件

public class与class

public的类名必须与文件名相同，且只有一个public类
每个class当中都可以有main（），设定程序入口
类体不能直接编写java语句
每一个类都对应一个.class文件

命名规范

类名：首字母都大写
变量名，方法名：首字母小写，其余首字母大写
常量名：全部大写

数据类型

浮点数
浮点数=符号位+指数位+尾数位
小数不要直接比较大小，而是比较差的绝对值
if(Math.abs(num-num2))<0.0000001);

String类型

  String s="123";
  byte num1=Byte.parseByte(s);
  int num2=Integer.parseInt(s);
  Long num3=Long.parseLong(s);
  float num4=Float.parseFloat(s);
  double num5=Double.parseDouble(s);
  boolean b=Boolean.parseBoolean(s);

字符串比较

import java.util.*;
public class search{
   public static void main(String[] args) {
       Scanner sc=new Scanner(System.in);
       String name[]={"a","b","c","d"};
       String find=sc.next();
       int flag=-1;
       for(int i=0;i<name.length;i++)
           if(find.equals(name[i])){
               flag=1;
               System.out.println("Find id!\n"+find);
               System.out.println(i);
               break;
           }
       if(flag==-1)
           System.out.println("Not Found!");
   }
}

类型转换

默认为int,double类型
long a=bL;加后缀。
float a=bf;
long y;
int x=(int)y;

输入

 public static void main(String[] args) {
     Scanner input=new Scanner(System.in);
     
     String name=input.next();    //字符串
     int age=input.nextInt();    //整数
     char a=input.next().charAt(0);    //字符
     double sala=input.nextDouble();    //浮点数
    }

位运算

正数三码相同，负数的反码符号位不变其余位取反，补码是反码+1；
1>>2,1/2/2;
1<<2;1* 2* 2;

数组

声明方式为array[]
double hens[]={1,2,3,4,5};
double hens[]=new double[5];

char arr[]=new char[26];

String strs[]={“a”,“b”};
String strs[]=new String[]{“a”,“b”};

下标访问
for(int i=0;i<hens.length;i++)
System.out.println(hens[i]);

输入赋值：
hens[i]=input.nextDouble();

声明：int arr[][]=new int[2][3];

int[]x,y[]; x是一维，y是二维数组

数组的插入

import java.util.*;
public class insert{
 public static void main(String[] args) {    
     Scanner sc=new Scanner(System.in);
     int temp=sc.nextInt();
     
     int arr[]={10,12,45,90};
     //找到插入的下标
     int index=-1;
     for(int i=0;i<arr.length;i++){
         if(temp<=arr[i]){
             index=i;
             break;
         }
     }
     if(index==-1){
         index=arr.length;
     }
     //扩容插入
     int arrNew[]=new int[arr.length+1];
     for(int i=0,j=0;i<arrNew.length;i++){    //赋值到新数组
         if(i!=index){
             arrNew[i]=arr[j++];
         }else{
             arrNew[i]=temp;    //j此时暂停
         }
     }
     //打印
     arr=arrNew;    //回收
     for(int c:arr)
         System.out.print(c+"\t");
 }
}

翻转数组

public class arr{
    public static void main(String[] args) {
        int arr[]={1,2,3,4,5,6};
        int temp=0;
        int len=arr.length;
        for(int i=0;i<len/2;i++){    //注意循环到len/2
            temp=arr[len-1-i];
            arr[len-1-i]=arr[i];
            arr[i]=temp;
        }
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

数组扩容

public class arr{
    public static void main(String[] args) {
        int arr[]={1,2,3};
        int arrNew[]=new int [arr.length+1];
        for(int i=0;i<arr.length;i++){
            arrNew[i]=arr[i];
        }
        arrNew[arrNew.length-1]=4;
        arr=arrNew;    //原来的arr被销毁，新的arr和arrNew指向同一地址
        for(int c:arr){
            System.out.print(c+" ");
        }
    }
}

打印杨辉三角

public class arr2{
    public static void main(String[] args) {
        int arr[][]=new int [10][];
        for(int i=0;i<arr.length;i++){
            arr[i]=new int [i+1];
            for(int j=0;j<arr[i].length;j++){
                if(j==0||j==arr[i].length-1){
                    arr[i][j]=1;
                }else{
                    arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                }
            }
        }
        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();
        }
    }
}

随机数生成

 int []arr=new int [10];
 for(int i=0;i<arr.length;i++){
     arr[i]=(int)(Math.random()*100)+1; //随机生成0~100的数
 }

递归

执行方法时，每次调用会创建独立的栈
达到结束条件时，从顶栈返回

阶乘

public class recursion{
  public static void main(String[] args) {
  	Test t=new Test();
  	int res=t.test(10);  //计算10的阶乘
  	System.out.print(res);
  }
}
class Test{
  public int test(int n){
  	if(n==1)return 1;
  	else return n*test(n-1);
  }
} 

fibo

	public int fibo(int n){ //第n项的数
		if(n==1||n==2){
			return 1;
		}else{
			return fibo(n-1)+fibo(n-2);
		}
	}

前一天桃数=（后一天桃数+1）*2；

	public int peach(int day){	//第day天的桃数
		if(day==10){
			return 1;
		}else{
			return (peach(day+1)+1)*2;
		}
	}

汉诺塔问题

public class hannuota{
   public static void main(String[] args) {
   	Tower T=new Tower();
   	T.move(5,'A','B','C');
   }
}
class Tower{
   public void move(int num,char a,char b,char c){
   	if(num==1){
   		System.out.println(a+"->"+c);
   	}else{
   		move(num-1,a,c,b);	//借助c将Num-1个从a移动到b
   		System.out.println(a+"->"+c);
   		move(num-1,b,a,c);	//借助a将num-1个从b移动到c
   	}
   }
}

枚举

自定义枚举

1)构造器私有化
2)内部创建对象public final static
3)去除set()方法
4)根据需要，赋予多个属性

class Season{
    String name;
    String des;
    public final static Season SPRING =new Season("春天","温暖");
    public final static Season SUMMER=new Season("夏天","炎热");
    private Season(String name,String des){
        this.name=name;
        this.des=des;
    }
}
class Main{
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }
}

enum

1)enum替代class
2)常量用,间隔
3)常量写在定义之前
4)继承Enum类
5)可以实现接口
6)不能继承其他类

import java.util.*;
enum Season{

    SPRING("春天","温暖"),SUMMER("夏天","炎热");
    String name;
    String des;
    private Season(String name,String des){
        this.name=name;
        this.des=des;
    }
       public String toString(){
        return name+" "+des;
    }
}
public class Main{
    public static void main(String[] args) {
        Season s=Season.SPRING;
       //对象名 .name()
       System.out.println(s.name());
        //输出在枚举中的次序 .ordinal()
        System.out.println(s.ordinal());
        //遍历输出枚举对象 .values()
        Season[]values=Season.values();
        for(Season season:values){
            System.out.println(season);
        }
        //从枚举中查找SPING，并返回 .valueOf()
        Season spring=Season.valueOf("SPRING");
        System.out.println(spring);
        //比较编号  .compareTo()
        System.out.println(Season.SPRING.compareTo(Season.SUMMER));
   }
}

注解

@Override
public @interface Override{}//注解类
//标记子类重写父类方法，未重写则编译失败
//只能修饰方法

@Deprecated
//标记已过时，不推荐使用
//版本过渡

@SuppressWarnings
//抑制编译器警告

@SuppressWarnings({"all"})
//排除所有警告

@Test 
//运行样例

异常

异常体系图

编译异常

try/catch处理机制

1.异常发生，直接进入catch

2.finally都会执行,关闭连接，释放资源

3.多个异常，多个catch分别捕获，子类异常在前面，父类异常(Exception)在后面

4.try-finally,不捕获异常

5.当finally没有return 语句，则返回catch中的临时结果

throw处理机制(甩锅机制)
顶级JVM输出异常信息，退出程序

public void f()throws Exception{}
1.throws由方法调用者处理

2.重写方法的子类异常是父类异常的子类或者相同

3.f1()调用抛出编译异常的f3()方法，则f1也要抛出相同异常,运行异常可以直接调用不用

自定义异常
throws接·异常类型，throw接对象

//自定义异常throw，继承RuntimeException
throw new AgeExcption("年龄异常")
class AgeExcption extends RuntimeException{
    public AgeExcption(String message){
        super(message);
    }
}

import java.util.Scanner;

public class system {
    public static void main(String[] args) {
        try {
            String name="fwj";
            String pwd="123456";
            String email="3321356@qq.com";
            user(name,pwd,email);
            System.out.println("注册成功");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    public static  void user(String name,String pwd,String email){
        int len=name.length();
        if(!(len>=2&&len<=4)){
            throw new RuntimeException("用户名长度在2~4之间");
        }
        if(!(pwd.length()==6&&isDigit(pwd))){
            throw new RuntimeException("密码格式错误");
        }
        int i=email.charAt('@');
        int j=email.charAt('.');
        if(!(i>0&&j>0)){
            throw new RuntimeException("邮箱必须包含@和.");
        }
    }
    public static  boolean isDigit(String pwd){
        char[]chars=pwd.toCharArray();
        for(int i=0;i< chars.length;i++){
            if(!(chars[i]<='9'&&chars[i]>='0')){
                return false;
            }
        }
        return true;
    }
}

包装类

装/拆箱

//自动装箱int-<Integer
Integer integer=n;
//(底层是Integer.valueOf(n))

//自动拆箱Integer-<int
int n=integer;

Integer

转换

//Integer-<String
Integer i=100;
String str=i+"";
String str=i.toString();
String str=String.valueOf(i);
//String-<Integer
String str="123";
Integer i=Integer.parseInt(str);
Integer i=new Integer(str);

面试题

Integer n1=128;
Integer n2=128;
//底层是Integer.valueOf(n),-128~127时直接比较n,否则new对象
System.out.println(n1==n2);//false

String

1)一个字符2个字节

2)String 不能被其他类继承

3)底层存放在private final char value[]，value地址不能修改,不能指向新的地址，但是内容可以变化

4)字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享。

对象创建的区别：

//返回常量池中的地址
s.intern()

//创建一个对象
String a="abc"+"cde";

//a,b直接指向常量池
String a="hello";
String b="world";
//c指向堆中的String对象,间接指向常量池
String c=a+b;
String d="helloworld";
c!=d;//地址不同，c指向堆，d指向常量池
//常量相加在池中，变量相加在堆中

//final类的String每次更新更新都要开辟新空间,效率低

String 方法

String s="abc";

s.length(); //字符串长度

s.isEmpty();

s.charAt(index); //返回索引处的字符

s.equals(obj); //对象比较

s.compareTo(s2); //字典序比较
/*
字典序比较：
 	如果两个字符串不同，则它们在某些索引处具有不同的字符
 compareTo返回两个字符串中位置k处的两个字符值的差值，即值： 
 this.charAt(k)-anotherString.charAt(k)

	如果没有它们不同的索引位置，则较短的字符串按字典顺序位于较长的字符串之前。 在这种情况下， compareTo返回字符串长度的差异 - 即值： 
 this.length()-anotherString.length()
*/


s.indexOf(65); //返回指定字符第一次出现在字符串内的索引
s.indexOf(s2); //返回指定子字符串第一次出现的字符串内的索引
s.lastIndexOf(s2); //返回指定子字符串最后一次出现的字符串中的索引

s.substring(beginIndex);//返回一个子字符串。 子字符串以指定索引处的字符开头，并扩展到该字符串的末尾。
s.substring(beginIndex,endIndex);

s.concat(s2); //连接s+s2

s.replace(oldChar,newChar);//将字符串中的指定字符进行替换

s.split(" ");//字符串按空格分隔

s.toLowerCase();
s.toUpperCase();

s.trim();//返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。 

s.toCharArray();//将此字符串转换为新的字符数组。

字符翻转

public static String reverse(String str,int start,int end){
    if(!(str!=null&start>=0&&end>start&&end<str.length)){
        throw new RunTimeException("参数异常');
        }
    char[]chars=str.toCharArray();
    char temp=' ';
    for(int i=start,j=end;i<j;i++,j--){
        temp=chars[i];
        chars[i]=chars[j];
        chars[j]=temp;
        }
        return new String(chars);
      }

格式输出：

public class split {
    public static void main(String[] args) {
        String name="feng wen jie";
        printName(name); //jie,feng.W
    }
    public static void printName(String name){
        if(name.length()==0){
            System.out.println("名字长度不能为空");
            return;
        }
        String[]names=name.split(" ");
        String format=String.format("%s,%s.%c",names[2],names[0],names[1].toUpperCase().charAt(0));
        System.out.println(format);
    }
}

StringBuffer

//转换
String--StringBuffer
String s="hello";
//1
StringBuffer sb1=new StringBuffer();
sb1.append(s);
//2
StringBuffer sb2=new StringBuffer(s);

StringBuffer--String
//1
StringBuffer sb=new StringBuffer("hello");
String s1=sb.toString();
//2
String s2=new String(sb);

StringBuffer方法

 * 1.append 追加 s=null,append(s)返回"null",len=4
 * 
 * 2.delete(start,end) 删除 start~end-1 
 * 
 * 3.replace(start,end,s) 用s替换start~end-1
 *
 * 4.indexOf 第一次索引
 * 
 * 5.insert(index,s) index位置插入s 
 * 
 * 6.length

价格分割

public static void main(String[] args) {
    String price= "123456789.12345";
    StringBuffer sb=new StringBuffer(price);
    int start=sb.LastIndexOf(".");
    for(int i=start;i>0;i-=3){
        sb.insert(i-3,",");
    }
    System.out.print(sb); 
}

StringBuilder

不是线程安全，单线程优先使用

Math

常用方法

1.Math.abs

2.Math.pow

3.Math.ceil  //向上取整

4.Math.floor //向下取整

5.Math.round //四舍五入

6.Math.sqrt

7.Math.random //[0,1)
//返回a~b的随机整数
(int)(a+Math.random()*(b-a+1))

Arrays

1.Arrays.toString(int []) //格式输出[a,b,c]

2.Arrays.sort(int []) //默认排序
//实现接口,定制排序
Arrays.sort(arr,new Comparator(){
    public int compare(Object o1,Object o2){
        Integer i1=(Integer)o1;
        Integer i2=(Integer)o2;
        return i2-i1;//大到小排序
        }
   });

3.//自定义接口的冒泡排序
public class B_sort {
    public static void main(String[] args) {
        int[]arr={1,5,-1,4};
        B_sort(arr,new Comparator(){
            public int compare(Object o1,Object o2){
                int i1=(Integer)o1;
                int i2=(Integer)o2;
                return i2-i1;//小到大
            }
        });
        System.out.println(Arrays.toString(arr));
    }
    public static void B_sort(int[] arr,Comparator c){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(c.compare(arr[j],arr[j+1])>0){
                     int temp=arr[j];
                     arr[j]=arr[j+1];
                     arr[j+1]=temp;
                }
            }
        }
    }
}
4.Arrays.binarySearch(arr,num) //对排好序的数组进行查找，返回下标，不存在返回-（low+1)low是应该存在的下标位置

5.Arrays.copyOf(arr,arr.length) //拷贝

6.Arrays.fill(arr,num) //用num替换数组中所有的数

7.Arrays.equals(arr1,arr2) //元素是否相同

8. List asList=Arrays.asList(1,2,3,4,5) //转化为List

属性排序

import java.util.Arrays;
import java.util.Comparator;

public class sorted {
    public static void main(String[] args) {
        Book[]books=new Book[4];
        books[0]= new Book("红楼梦", 100);
        books[1]= new Book("金瓶梅新", 90);
        books[2]= new Book("青年文摘20年", 5);
        books[3]= new Book("java从入门到放弃", 300);
        //价格从大到小
        Arrays.sort(books, new Comparator() {
            public int compare(Object o1, Object o2) {
                Book book1=(Book)o1;
                Book book2=(Book)o2;
                return book2.getPrice()-book1.getPrice();
            }
        });
        System.out.println(Arrays.toString(books));
        //书名长度
        Arrays.sort(books, new Comparator() {
            public int compare(Object o1, Object o2) {
                Book book1=(Book)o1;
                Book book2=(Book)o2;
                return  book1.getName().length()-book2.getName().length();
            }
        });
        System.out.println(Arrays.toString(books));
    }
}

System

1.System.exit(0) //正常退出状态

2.System.arraycopy(arr1,0,arr2,0,3)
//从arr1数组从0开始拷贝到arr2从0开始，拷贝3个

3.System.println(System.currentTimeMillens)

大数字

//大数字运算
BigInteger bigInteger=new BigInteger("x"); //字符串形式
bigInteger.add("x")
bigInteger.substract("x")
bigInteger.multiply("x")
biginteger.divide("x")
//高精度
BigDecimal bd=new BigDecimal("x")
add()
substract()
multiply()
a.divide(b,BigDecimal.ROUND_CEILING) //精度控制

Date

格式化输出日期

日期转化为Date

Calendar

泛型

泛型引入


声明类时声明泛型

在MyDate中实现Comparable接口，主方法中只用调用compareTo方法

自定义类型

class <T,R,M>{}

数组和static方法不能用自定义泛型
自定义泛型接口

interface IF<U,R>{}