java学习笔记

1.简单java基本结构：定义运行类
 public class 文件名类名{
  public static void main(String[] args){
   类的内容;
  }
 }
2.简单数据类型及声明变量
 字符型2字节：char(unicode编码:0～2^16-1)：'男' 97(='a')
 字符串型：String："一本书" in.next()；String类的方法toCharArray()可以将字符串转换成字符数组char[]
 字节型1字节：byte(-2^7～2^7-1)
 短整型2字节：short(-2^15～2^15-1)
 整型4字节：int(-2^31～2^31-1)：3 in.nextInt()
 长整形8字节：long(-2^63～2^63-1)
 单精度型4字节：float(1.4E-45～3.4E+38,-1.4E-45～-3.4E+38)
 双精度型8字节：double(4.9E-324～1.7E+308,-4.9E-324～-1.7E+308)：3.0 in.nextDouble()
 布尔型1字节：boolean：true false in.nextBoolean()
 扫描仪：Scanner：new Scanner(System.in)
 声明变量：
  String x="变量内容";
  int x=3;
  boolean x=false;
 强制类型转换：(类型名)表达式
  int x=(int)(3.5+4.2);
  double x=Double.parseDouble("5.67");
3.输出及备注
 单行输出：System.out.print("输出字符串");
 换行输出：System.out.println("输出字符串");
 输出制表符：System.out.println("制表符\t制表符");
 输出换行符：System.out.println("换行\n换行");
 输出连接符：System.out.println("字符串a"+"字符串b");
 单行备注：//备注内容
 多行备注：/*多行备注内容*/
4.输入(导入并声明扫描仪)
 导入扫描仪：
  import java.util.Scanner;
  import java.util.*;
 声明扫描仪：
  Scanner 扫描仪名称=new Scanner(System.in);
 使用扫描仪输入：
  String 变量名=扫描仪名称.next();
  int x=in.nextInt();
  double x=in.nextDouble();
5.if条件语句
 if(条件a成立){
  内容a;
 }
 else if(条件b成立){
  内容b;
 }
 else{
  内容c;
 }
 条件语句(三元算术运算符?)：
  int c=a>5?1:2;//如果a>5,c=1;如果a<=5,c=2
6.switch选择条件语句
 switch(整型或字符型变量){
  case 选项1:
   内容1；
   break;
  case 选项2:
   内容2；
   break;
  default:
   内容3；
   break;
 }
7.布尔型boolean中相等：==与.equals()的用法
 int、double、boolean、char等以小写字母开头的数据类型用==
 String、Integer等以大写字母开头的数据类型用.equals()方法
8.数组
 定义数组及内容：
  String[] 数组名=new String[]{"变量值1","变量值2","变量值3"……"变量值n"};
  String[] 数组名={"变量值1","变量值2","变量值3"……"变量值n"};
 定义数组及变量个数：
  int[] 数组名=new int[数组变量个数];
 数组第i个变量：i取0至(n-1)
  数组名[i-1]
 数组内变量的数量：
  数组名.length
 数组间复制：（System.arraycopy()拷贝的是引用，而不是对象，对象本身不改变）
  System.arraycopy(source,i,dest,j,x);//语句的意思就是：复制源数组从下标i开始的x个元素到目标数组，从目标数组的下标j所对应的位置开始存取
 数组内容排序：
  Arrays.sort(数组名);//为数组排序,为java.util.Arrays类的方法
 数组内元素的读取可以使用for-each语句：
  例子：for(String a:b){使用a的语句}，表示依次提取b数组的元素赋值给a并在语句中操作
9.运算符
 赋值运算符：=
 算术运算符：+ - * / 取余%
 关系运算符：< > >= <= == !=
 逻辑运算符：非! 且&& 或||
 运算符优先级：
  赋值>算术>关系>逻辑
  非>且>并
10.产生随机数
 导入声明：产生随机整型自然数(用法同Scanner)
  导入：import java.util.Random;
  导入：import java.util.*;
  声明：Random 变量名=new Random();
  将随机数赋值给整型变量x：int x=随机数变量名.nextInt(随机数产生范围);
 函数法：产生0-1范围内的双精度型随机数，支持多线程
  Math.random()
11.循环语句
 for循环语句：先判断后执行，i++语句不属于执行语句
  for(int i=0;i<n;i++){
   内容;//n表示i取值上限
  }
 while循环语句：先判断后执行，i++语句属于执行语句
  int i=0;
  while(i<n){
   内容；//n表示i取值上限
   i++;
  }
 do while循环语句：先执行后判断
  int i;
  do{
   i=in.nextInt();
   内容；//n表示i取值上限
   i++;
  }while(i<n);
 break语句的功能是结束所在的循环；而continue语句的功能是跳过当次循环未执的代码，直接执行下一次循环
12.一元、二元、三元算术运算符
 一元运算符：++ --
  i++ <=> ++i <=> i+=1 <=> i=i+1;
  i++先使用后对自身加1; ++i先对自身加1后使用；i--与--i同
  int i=1; int a=i++; =>a=1;i=2;
  int i=1; int a=++i; =>a=2;i=2;
 二元运算符：+ - * / %
 三元运算符：?
  a>5?1:2 表示a>5时为1，a<=5时为2
13.函数（子程序）定义
 返回值类型 函数名 (参数类型 形式参数, 参数类型 形式参数,……){
  程序代码
  return 返回值;
 }
 备注1：无返回值时返回值类型为void，程序代码无return语句
 备注2：函数可以在当前类中定义，需与main函数同级别，被main函数调用时前面要加上static

14.类和对象
 对象的产生：类 对象名=new 类();//其数据类型为基本数据类型或引用类型（String、一些自定义的类、reference等）
 类：类的成员变量（也称为类的属性），类的成员方法（也称为类的成员函数）
 类中结构变量与成员方法局部变量同名时，成员方法访问的是局部变量，即同一个类中局部变量优先级大于成员变量
 类中构造方法作用同子程序（可以返回多个成员变量值），成员方法作用同函数（只能返回1个值或返回void型）
15.java的运行main()函数方法
 main()方法的意义：
  public static void main(String[] s){}
  共有的 静态的(直接用类调用的) 无返回值的 方法名称为main的 形参为字符串数组的 方法
 java虚拟机运行机制：(JVM会自动为main方法捕捉异常)
  1.start;//虚拟机开始工作
  2.try{classname.main(new String[]);}catch(Throwable e){e.printStackTrace();}//调用main()方法，语法：java classname (new String[])=={s[0] s[1] ... s[s.length-1]}
  3.over;//虚拟机停止工作
16.类的几大组成要素及static：
 static不能用来修饰正常的类，但可以修饰类的内部类。
 1.代码块：调用类或类的对象时被先执行，静态代码块只在[类]第一次在内存中调用时执行1次（静态代码块执行优先级最高，常用于静态成员变量的初始化），非静态则[new类的对象]产生一次执行一次（非静态代码块作用与构造方法的代码块一样，不过类可能有多个构造方法重载，每个构造方法中代码一般不同，就可以把所有构造方法中先执行的相同的代码以非静态代码块方式表示，常用于非静态成员变量的初始化）。注：代码块必须由{ }括起来，代码块实际功能发挥的作用较小，基本可以用其它的要素代替。
 2.构造方法：特殊的代码块，用new产生一个对象（开辟一个类的内存空间）执行一次，不允许使用static修饰符（构造方法和非静态代码块常用于非静态成员变量的初始化）
 3.成员变量：有变量类型，可以直接赋值初始化，静态变量为类的变量
 4.成员方法：有变量类型(void为特殊的类型)，方法中代码在方法每调用一次执行一次，静态方法为类的方法（方法[不管方法是否静态的]内部声明变量不能用static，static只能用来修饰类的成员、类的静态代码块或static型的内部类的成员，就是说static绑定类的静态内存空间）（方法可以理解为有返回值的方法型式的代码块，而类的代码块亦可以理解为返回值为void的初始化方法）（方法中可以包含有带标签的代码块，格式：标签名:{代码块}；类的代码块则本身不能带标签，而代码块内部的代码块可以带标签）（return语句可以跳出方法，void型方法也可以用return;跳出，但return后面不能有无法访问的语句，可以用一个条件语句跳出；return;语句不能用来跳出类的代码块）
 5.内部类：内部类相当于类中的class型的特殊的成员，编译时会产生外部类名$内部类名的class文件。
  a.内部类可以像类中的其它成员一样用private、static修饰符（而一般类只有final、public与缺省型修饰符）。
  b.static型的内部类成员可以在外部类外直接通过外部类名.内部类名.成员来调用，非static型内部类在外部类外面需要用外部类的实例化对象调用（语句结构：Outer.Inner inner_obj=outerobj.new Inner()）
  c.非static内部类中不能声明static型的成员变量和成员方法。（可能因为非static内部类需要外部类的实例化对象来调用，假设非static内部类中存在static型的成员，每一个外部类的实例化对象都会在内存中产生一个内部类的静态内存空间来存放这些静态成员，从而内存中存在多个内部类的静态内存空间依附于实例化对象的空间，会造成内存空间比较混乱）（而static内部类中定义的static型的成员需要的静态内存空间则依附于外部类的静态内存空间，在内存中只有一个固定的空间）
  d.在方法中可以定义内部类（或匿名内部类），方法中的内部类作用相当于方法中的语句，方法中只有定义内部类后面的语句才能调用内部类的成员，前面的语句和方法外不能调用方法中内部类。（方法中内部类中可以调用外部类的成员或方法中定义的final型局部变量，而不能调用方法中的非final型局部变量）
  e.内部类可以有自己的内部类（可以有多重内部类嵌套），内部类可以继承一个类或实现多个接口
  f.由于声明内部类会破坏程序的一般性结构，故开发中不建议使用内部类。
17.类的继承树
 备注：子类可以覆盖继承父类的成员（包括成员变量、成员方法、内部类，不包括代码块[因为代码块没有名字]、构造方法[不能继承需要调用]）
 1.继承成员变量：子类可以继承父类的所有成员变量（静态变量继承后仍是子类静态变量）（父类private变量继承后仍是私有变量，但子类不能用this.变量调用，可以通过this或super.非private方法调用，即父类私有变量可继承，但继承后虽然是子类的变量，其访问权限仍是在父类中，子类不能直接使用）
 2.继承成员方法：子类可以继承父类的所有成员方法（静态方法继承后仍是子类静态方法）（private方法继承同private变量）
  2.1覆盖方法：子类方法可以通过复写来覆盖父类的方法，子类的覆盖方法要求访问权限不能比父类严格，静态方法覆盖必须为仍是静态的。
  2.2只有方法覆盖时调用父类属性必须用super，其他情况用super与this均可。
 3.构造方法不继承但必须调用：子类构造方法默认调用父类的无参构造方法（所以要用super或this放在第一行调用需要的那个构造方法，而父类最好将无参构造方法定义出来以防子类默认调用时不存在而出错）
 4.内部类可以继承
 5.代码块可以继承
 总结：子类可以继承父类除构造方法外的所有属性，而子类的构造方法必须直接或间接调用父类构造方法（构造方法调用会一直延伸至基类Object）
 本质：子类并不是真的继承父类成员，而是子类能调用父类的静态成员，子类对象能调用父类的除了被覆盖的成员外的所有成员（即子类对象不只是子类的对象，也是父类的对象，这就是类的多态性）
18.抽象类和接口
 1.抽象类和接口共有的特征：成员方法可能是抽象方法，不能创建实例化对象，作用是当做模板被子类继承
 2.抽象类：特殊的类，用abstract修饰，不能创建实例化对象，含有抽象方法的类必须是抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
 3.接口interface：特殊的抽象类
  a.接口内定义的变量均为全局静态常量（可省略public static final），必须赋初值
  b.接口内定义的方法必须为全局抽象方法（可省略public abstract，不能是静态的），接口不能创建实例化对象
  c.类可通过实现(implements)接口来继承接口的成员，一个类可以实现多个接口，类的extends关键字必须在implemnets关键字之前(java中的多继承机制）
  d.一个子接口可以继承(extends)多个父接口
  e.接口中可以有内部类，内部类默认为全局静态的（可省略public static，内部类不是final的），可以被接口的子类继承
  f.接口内没有构造方法，可以定义与接口名相同的抽象成员方法
  g.同构造方法一样，接口内不能有代码块
19.Object类
 Object类是所有类直接或间接的父类，一个类如果没有继承其它类的话会默认继承Object类
 toString()方法：打印对象时自动被调用（即System.out.print(obj);等价于System.out.print(obj.toString);），可以在类中重写，返回值为String型。
 equals()方法：比较两个对象是否指向同一内存空间，在String类（和数组）中已经进行了重写用来比较实际内容
20.final关键字
 final意思为最终的
 1.final修饰的类为最终类，不能被继承
 2.final修饰的方法不能被子类复写，可以被子类继承
 3.final修饰的变量（成员变量或局部变量）即为常量，只能赋值一次（final修饰的方法的形参除外）
  public static final共同标记常量时，这个常量就成了全局的常量
 4.方法中定义的内部类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期，将一个方法的形参定义成final也是可以的，这就限定了我们在这个方法中修改形式参数的值。
21.对象的多态性（通过指针理解）
 1.父类的变量可以指向子类的对象；
 2.子类的变量可以强制指向父类的变量（前提是父类的变量指向了子类或子类的子类的对象，不然编译通过运行出错）；
 3.instanceof关键字判断一个对象是否是一个（也可以是接口）类或者这个类的子类的对象，返回布尔型值，格式：对象 instanceof 类或接口；
 4.类的继承不是真的继承，而是子类对象可以调用父类的成员，子类对象会从下到上依次调用子类父类的成员；
 5.一个父类变量指向子类的对象时，这个变量表面上是父类的，实际上是子类的，并不会实际损失精度；
22.方法中的内部类
 1.方法中的内部类作用权限只在内部类后面的方法体中有效；
 2.方法中的匿名内部类格式：new 父类或父接口(){覆盖父类方法或实现父接口}，表示：class 匿名类 extends 父类{覆盖或实现父类方法}，然后new 匿名类。
23.继承与多态性本质
 继承分为静态成员继承和非静态成员继承：（子类可以覆盖父类的成员变量和成员方法）
  静态成员继承：静态成员是类的成员，依附于类的静态内存空间；如果父类静态成员在子类中没有被覆盖，则子类的这个静态成员实际并不属于子类的静态空间，而是属于父类的静态空间；如果父类静态成员在子类被覆盖，则子类的这个静态成员和子类中新定义的静态成员属于子类的静态空间。
  非静态成员继承：非静态成员是类的对象的成员，依附于实例化对象的内存空间；非静态成员继承通过子类构造方法用super关键字调用父类构造方法实现的，产生一个子类新对象（new 子类构造方法;），子类构造方法调用父类构造方法（super(参数);），相当于这个新对象既调用了子类构造方法又调用了父类构造方法，这个对象既是子类的对象(子类中定义的新成员及覆盖父类的成员),又是父类的对象(父类中没被覆盖的成员)；所以对象的继承并不是真的继承，实质是子类调用父类。
 多态性基本原理：子类对象既是子类的对象，又是父类的对象
  通过指针解释多态性：父类的变量可以直接指向子类的对象（自动向上转型），子类的变量可以指向(指向(instanceof子类的)对象的)父类的变量（强制向下转型）；对变量的操作实际上是对变量指向对象的操作。

24.java程序运行中的异常处理
 1.JVM（java虚拟机）自动为main方法捕捉异常（输出异常信息：捕捉到的Throwable.printStackTrace();）
 2.运行的代码中如果存在异常，处理方式分为不处理和用try-catch-finally进行处理两种情况
  1.代码内对异常不进行处理：抛出异常，结束程序>>java虚拟机捕捉并输出异常信息
  2.代码内用try-catch-finally处理：分为catch捕捉到和未捕捉到try中的异常两种
   1.try产生异常，try代码块结束运行>>catch捕捉到异常并运行catch代码块>>运行finally代码块
   2.try产生异常，try代码块结束运行>>catch未捕捉到异常>>运行finally代码块,结束程序>>java虚拟机捕捉并输出异常信息
 3.代码中可以通过throw关键字抛出new Exception对象
 4.方法可以通过throws关键字抛出Exception类（并不是真的有异常，而是调用此方法时必须进行异常处理），调用此方法必须用try-catch-finally捕捉处理
 5.可处理的异常类均继承自Exception类，可以自定义异常类（必须继承Exception类）
 6.catch异常对象（假设赋值给e变量）处理时常用语句：e.printStackTrace();或System.out.println(e);
25.包package
 1.定义类所在的包：package 外层文件夹.内层文件夹;
 2.编译中生成包的目录：javac -d . Filename.java;(注意：点的两边都有空格；-d表示生成目录；点表示在当前目录生成)
 3.运行class文件：java packagename.classname;(注意：各层目录间用点隔开)
 4.外部调用一个包中的类：import packagename.classname;或用import packagename.*;导入整个包中的类
  另外需要注意的是，在 java 中有这样的规定：导入包中全部类或是导入指定的类，对于程序的性能是没有影响的，所以在开发中可以直接写导入全部类会比较方便。还需要注意不能同时导入不同包中的两个相同名称的类，此时需要将同名类其中一个类通过“包名.类名”的方式调用。
 5.JDK中的常用包：java.lang(包含java中的核心类，默认包)、java.awt(抽象窗口工具集)、javax.swing(建立用户图形界面)、java.applet(applet程序通过HTML调用)、java.net(网络相关)、java.io(输入输出)、java.util(实用工具)等等。
25.java命名习惯
 1.包名中的字母一律小写
 2.类名、接口名应当使用名词，每个单词的首字母大写
 3.方法名，第一个单词小写，后面每个单词的首字母大写
 4.常量名中的每个字母一律大写
26.jar文件
 1.在cmd命令行中生成jar文件：jar -cvf jarname.jar demo
  -c表示创建新档案；-v表示输出详细信息,可省略；-f表示指定档案文件名；jarname.jar表示压缩的jar文件名；demo表示要压缩的目录或文件列表，用空格隔开
 2.jar文件若要被调用，环境变量classpath必须加上jar文件的目录文件位置
27.枚举类型enum
 1.enum是一种特殊的数据类型，默认为static final的，表示为一些常量的数组集合，定义语句：public enum 变量名{常量1,常量2,……};，可以通过变量名.常量来表示某一个具体枚举元素的值
 2.被enum定义的变量名变成一种数据类型（有点类似于内部类，但有区别），此变量名定义的变量只能取枚举数组中的值；此变量名的方法有：.values()返回所有枚举元素组成的数组、.valueOf(String)以字符串形式返回某个具体枚举元素
 3.枚举值可以被传递到switch选择语句中，每个case句处理一个特定的枚举元素值，switch(变量)中的变量为enum变量名定义的变量
28.java多线程
 1.线程的激活：
  1.此类必须继承Thread类或者实现Runnable接口
  2.线程的代码必须写在run()方法中
  3.在主程序中通过Thread类的对象的start()方法激活
 2.线程的常用方法：wait(),notify(),sleep(),join(),getname(),start(),run()等等,注意很多方法本身会抛出异常，需要用try-catch捕捉
 3.用synchronized关键字对多线程操纵同一个对象进行同步