Java新手笔记

正文之前：据说学习Java时发帖子能加快学习效率，以下是我学习时整理的一些笔记和自己写的一些代码，希望得到大佬指正。
别的先不说。先把这个整上！

public class HelloWorld{	
	public static void main(String[] args){
		System.out.println("HelloWorld!");
	}
}

~~一个源文件只能有一个公共类(public),且文件名与该类同名
~~命名规范：类名首字母大写；方法和标识符第一个单词小写，从第二个单词开始，首字母大写
~~成员变量：方法外部，类的内部定义的变量，从属于对象，生命周期随对象始终。
若不主动初始化（赋值），他会自动初始化为默认值（int 0；double 0.0;char “\000”;boolen "false
~~常量命名：全部使用大写和下划线
~~八进制 O开头 十六进制 Ox/OX开头 二进制 Ob/OB开头
~~float 单精度，精确七位有效数字 double 双精度，14位
~~浮点型默认位double，单精度定义：float f=3.14f/3.14F; （F不能省略）
~~浮点数不能用于比较，不精确
~~遇到运算符时，char类型自动通过Unicode转为数字
~~二元运算符中，若两个操作数中有一个lang型，则结果位lang型，否则位int型
取余运算中，结果符号与左边的操作符相同
~~b=a++; //先b=a，再a++ b=++a；//与前边相反，先++a，再b=a
~~&&短路与，有F则F ||短路或，有T则T ^异或，同则F,异为T ，&与， |或， ！非
~~位运算： 3 0011 <<左移运算，相当于乘以2
                   4 0100 eg：3<<1=6; 3<<2=12;
                   & 0000 >>右移一位，相当于取半
                    | 0111 ~取反（反码，补码）
                   ^ 0111
~~“+”字符连接符，“+”左右两边只要有一个位字符串，则表此意
~~x?y:z 若x位T，则返回y，否则返回z
~~键盘输入：String scr = scanner.nextLine();
读取字符串，但是如果作为第二次读取，他会读取第一次输入时按的回车键解决办法：空读取一次，不把其赋予给任何变量。scanner.nextLine();

import java.until,Scanner;
public class ScannerTest{
	public static void main(String[] args){
	Scanner scanner=new Scanner(System.in);
	String name=scanner.nextLine();
	int age=scanner.nextInt();
	}
}

String scr = scanner.nextLine();读取字符串，如果作为第二次读取，他会读取第一次输入时按的回车键解决办法：空读取一次，不把其赋予给任何变量。
在函数中，声明了一个 scanner 对象，并且调用了 close 方法，再次启动 scanner 的时候（或者在另一个函数中重新启动 scanner 时），就会遇到异常！
解决办法：使用多次Scanner get=new Scanner(System.in); 但是只在最后使用 get.close() 函数；
或者将Scanner get=new Scanner(System.in); 放在所有函数外层，同时在前面加上static修饰符，并且只在最后使用 iter.close() 函数！
~~new 对象；//new的是对象，每次new的对象都不相同(可以相等)，因为他们的地址不相同，即使他们同名；
~~this用于区分全局变量和局部变量(重名时)

void thistest(int x){
	this.x=x;	this.x表示对象的x属性，x表示传入的形参
}

     可以用于调用本类中的同名方法(只能放在第一句)
     不能用于static方法中
     this表示当前执行此方法的对象(this时形参)
     无参方法中默认存在this对象，方法中找变量，先在本方法中找，若找不到则找this
~~静态(static)方法和静态变量从属于静态类，及存在静态方法的类即为静态类，静态类只能使用静态方法，非静态类无限制
    静态初始化块：static{内容
                                        }
    静态初始化块在main中优先执行，即使main中的代码无意义
~~extends继承类只能有一个直接父类，final类无法被继承，接口(interface)可以多继承
    继承不能能使用父类的static方法/属性和构造方法
    选中+ctrl T；//查看类型层次
    方法返回值：子类<=父类
   ibject类时所有Java类的父类
   toString()方法是object类的一个方法
   print(x)为println(x.toString())改写toString()方法更改打印格式
   equals()时object类的一个方法，u1.equals(u2); //u1==u2?
    改写equals()方法更改判断标准
   super.x();super.x;调用父类的方法或属性(改写后也可以使用)
   构造方法第一句总是super(……)来调用父类对应的构造方法(可以不写)
~~封装

	同类	同包	子类	所有类
private	1
default	1	1
protected	1	1	1
public	1	1	1	1

   private表示私有，只有自己类中的可用
   default表示无修饰(默认)，只有同包可用
   protected表示可以被同包与其他包子类可用
   public表示该项目所有包中所有类均可用
~~final修饰变量：使变量转为常量不可再次赋值
           修饰方法：使方法不可被子类重写，但可以重载
           修饰类： 使类不可被继承
~~数组 长度确定，数组也是对象，元素是成员变量
    数组对象成员是可以改变的(与字符串不同)，改变后，地址不变，仍是同一个对象
   数组的初始化

      声明    type[] arr=name; type arr=name[]; //两种方法都可以
      初始化   type[] arr_name=new type[n];  //n为长度
      数组默认变量length  add.length   //数组的长度
      静态初始化  int[] arr={2,4,6}
    		 User[] arr={new User(1001,"张三"),new User(1002,"李四")}
      默认初始化  int[] arr=new int[3];   //三个元素为0(null……)
      动态初始化  int[] arr=new int[3];arr[0]=1;arr[1]=2;arr[2]=3;
      遍历(初始化/读取)  for(int i=0;i<=arr.length;i++){}
   		        for-each循环：专门用来读取数组或者所有的元素(遍历)
      				     for(type m:arr){print(m);} //type为数组元素类型，m为形参，arr为数组名

~~可视化窗口

import java.swing.JFrame;
  public Ax class extends JFrame{     //JFrame自带解决窗口闪烁问题，但效率较差(改回Frame，使用双缓冲)
     public void launchFrame(){
        this.setLocation(WINDOW_x,WINDOW_y);  //窗口左上角位置
        this.setSize(WINDOW_WIDTH,WINDOW_HEIGHT); //窗口大小
        this.title("Ax");    //窗口名字
        this.setVisible(true);    //窗口可视，默认为false
        }
     }
  public static void main(String[] args){
      Ax f=new Ax();  //newAx对象
                }

~~抽象(abstract) 抽象方法存在的类就是抽象类，即抽象方法只存在于抽象类中，抽象类中也可以存在非抽象方法
    抽象方法在抽象类中不能实现，在子类中必须实现
    严格限制子类的设计，使子类之间更加通用
    抽象类不能实例化，即不能通过new实例化，可以new子类
    抽象类只能被继承
    抽象类的意义：为子类提供统一的规范的模板，子类必须实现
~~接口(interface) 接口比抽象类更抽象，接口中有且仅有抽象方法
     接口更加规范的对子类进行约束，全面的专业的实现了规范与具体实现的分离
    例如：造房子时，图纸与房子实体的分离
     接口被实现(implement)类似于继承，从而实现方法，接口可以多继承，类只能单继承
     接口实现两个接口，若某变量被初始化为一个父类，则不能使用另一个父类的方法
     接口可以设置常量，不能有变量，且得大写
~~字符串 字符串对象不可能发生改变，只有对其操作然后赋值给另一个字符串
     字符串的拼接用"+"来完成，例如：String str=“abc”+“def”;
     "+"左右两边只要有一个是字符串，他就是连接符，不是运算符
     字符串的两种创建方式：String str1=“abc”;
                                             String str2=new String(“abd”);
     str1和str2是一样的，打印出来也是一样的，但是他们逻辑判断不相等，因为他们不是同一个对象，地址不同
     通常比较字符串是否相同时，使用equals：str1.(equals(str2))==true;
     String常用方法：

    System.out.println(s.charAt(n)); //打印字符串s下表为n的值s[n];
    s.length();  //字符串长度
    s1.equals(s2); //比较是否相同，不是比较相等
    s1.equalsIgnoreCase(s2);//比较相同，忽略大小写 
    s1.indexOf("AJ"); //s1中是否包含“AJ”，返回第一次出现的位置，不考虑次数
    s2=s1.replace("_","&");//符号替换，前边替换后边，实际s1不会发生改变
    s.startWith("How"); //字符串是否以“How”开头
    s.endWith("you"); //字符串是否以“you”结尾
    s.subString(n); //从下标n截取至结尾
    s.subString(m,n); //从下标m截取到下标n
    s=s.s1toLowerCase();//全转小写
    s=s.toUpperCase(); //全转大写
    s=s1.trim(); //去除字符串首尾空格，中间的不去除

    可修改字符串:

   //StringBuider线程不安全，效率较高(优先考虑使用它)，StringBuffer线程安全，效率较低
   StringBuider str11=new StringBuider("abcdef"); //由此创建的字符串对象，可以被改变
   str11.setCharAt(m,value); //修改str11下标为m的值为value
   str.append(String/Int……)； //重名方法，在str后添加元素，地址不变
   str.reverse();  //将str中的元素倒置
   str.insert(m,Char1);  //在str中从下标m插入Char1
   str,insert(m,Char1).insert(n,Char2)……；//可以无限写，链式调用，核心就是，该方法调用了return this。
   str.delete(m,n);  //删除下标m-n片段，不包括n

    数组的拷贝：
    System.arrayCopy(src,srcPos,dest,destPos,length);
    //其中src是被原数组，srcPost是原数组拷贝起始下标，dest是目标数组，destPost目标数组拷贝起始下标，length是拷贝长度
    根据数组的拷贝演变的操作：
    删除数组：本质还是拷贝，拷贝到自己身上也是可以的，代码中令dest=src
    源代码：

public static void delete(String[] str,int m,int n) {   //删除数组str中第m到第n个元素
  
  if(m<=str.length&&m>=0&&n>=0&&n<=str.length) {    //判断m和n是否在合理范围内
   
  }else {
   System.out.println("错误!!!");
  }
  
  if(n-m==str.length-1) {          //元素全部删除
   str=null;
  }else if (n-m>=1&&n-m<=str.length-1) {
   System.arraycopy(str, n, str, m-1, n-m+1);    //拷贝操作
   for (int i =str.length+m-n-1; i < str.length; i++) { //多余元素置空
    str[i]=null;
   }
  }else {
   System.out.println("错误!!!");
  }
  
  
 }

    数组扩容：本质是定义一个更大的数组，然后全部拷贝进去
    源代码：

 public static void addCapacity(String[] str,int x) {   //将数组str扩大x个元素
  
  	String[] str1=new String[str.length+x];
  	System.arraycopy(str, 0, str1, 0, str.length);
 }

~~冒泡排序法
原理：比较相邻两个元素，当顺序不对时，进行调换，全部调换结束即可在一端得出最大或最小元素
例如：51432
           15432 14532 14352 14325 //第一轮得出最大的5
           14325 13425 13245 //第二轮得出4
           13245 12345 //第三轮得出3
           12345
源代码：

public static int[] Sort(int[] a) {
  int temp;
  
  for (int i = 0; i < a.length-1; i++) {
 	 boolean flag=true;       //用于判断是否发生了元素换位置，换位置时为0
 	 for (int j = 0; j < a.length-1-i; j++) { //此处“-i”的作用：因为上一轮已经得出i个最大的数，此轮可以少循环i次
    
   		 if(a[j]>a[j+1]) {
  		 temp=a[j];
    		a[j]=a[j+1];
    		a[j+1]=temp;
    		flag=false;
   		 }
  	 }
   
  	while (flag) {       //不换需要换位置为1，结束循环，减少运行时间
    			break;
   			}
  }
  
 return a;
 } 

~~折半查找(二分法查找)
    原理：在一个从小到大的标准数组arr，查找元素key，取数组中间的元素mid与key比较，若相等则查找成功，若key小于mid，则在mid前的元素中查找，若key大于mid则在mid后边的元素中查找，不断执行这段操作，直至成功或失败。
    源代码：

public static int binarySearch(int[] arr,int value) {
  
  int low=0,high=arr.length-1;		//数组首位下标
  
  while(low<=high) {
	int mid=(low+high)/2;  		//中间元素下标
     	if(arr[mid]==value) {
       		return mid+1;		//当mid等于value时，返回mid的位置
   		}
   	if(arr[mid]<value) {		//当mid小于value时，在mid后边的元素中查找
		low=mid+1;
   		}
   	if(arr[mid]>value) { 		//当mid大于value时，在mid前边的元素中查找
   		high=mid-1;
   		}
   
 	}
  return -1;				//查找失败
 }

~~关于时间Date：
    Date d=new Date(n);//1970.1.1 00:00:00+n毫秒的时间(有考虑时区)
    Date d2=new Date();//当不输入n的值时，表示当前的时间
        d2.getTime(); //返回当前时间经历的毫秒数(d中的n)
        d2.after(d); //判断d2是都在d之后(before为之前)

暂时就这么多，随时跟进学习，随时更新~~