个人总结·JAVA基础

Java虚拟机负责解析和执行java程序
java类库提供最基础的java类及各种实用类

开发工具：这些工具都是可执行程序

javac.exe   编译工具
java.exe 运行工具
javadoc.exe 生成javadoc文件

jar.exe  打包工具

java优点
1 提供了一个解释环境JVM
   a 加速开发
   b 一次编译到处运行 跨平台
   c 多线程 

   d 支持动态更新

   e 取消了指针

   f  引入了垃圾回收

2 提供一个比较容易的方式编程
   a 更健壮 没有指针内存管理

   b 纯粹的面向对象编程

GC在内存空闲时 内存严重不足时工作

  标记清扫法 内存搬移法

java三大顶级元素 package import class
基本数据类型 byte short int long float double boolean char

引用数据类型  String 数组 接口类型 类类型

引用类型所引用的实例通过“.”能访问实例变量引用的方法

方法区/代码区 存放类的信息
堆区存放动态产生的数据
栈区保存基本数据类型值 引用数据类型的引用 加载方法时的帧
常量池 这个类型用的常量的一个有序集合

pc寄存器 存放下一条要执行的指令

局部变量
1 位置定义在方法中
2 使用 先赋值后使用
3 作用域  方法中{}中
4 生命周期 定义之后 方法结束之前
实例变量
1 位置 方法外类里面
2 使用 系统会默认赋值

3 作用域 类中

****   4 生命周期 从对象创建到GC回收内存结束

>>  算数右移运算 带符号为 最高位补符号位
>>> 逻辑右移运算 不带符号位右移

<<  左移运算 不带符号位左移

显式类型转换 long-》int
隐式类型转换 int-》long

精度小转精度高， 转之前是有符号在前面补符号位 ，无符号 在前面补0

可变长参数与数组使用时一样的
一个方法中只能定义一个可变长参数，并且要定义最后一个参数
封装 对类中的属性方法进行封装（外界不可见
继承 继承父类的属性和方法
多态 同一领域不同对象调用相同方法 结果不同
值传递传递的是数值 

地址传递 传递的是地址 引用

继承需要注意的
a 创建一个子类对象就必须先创建一个父类对象
b 子类构造器会默认调用父类构造器
c 父类的无参构造器失效
d 子类继承父类所有方法属性

super表示父类对象 this 表示当前对象

c语言多继承 java单继承优缺点
多继承造成了代码的浪费，引发了继承的多义性
java的接口可以完成多继承的功能 且使用接口可以一个项目多个功能同时开发

实现多态必须满足的条件
a 子类必须重写父类的方法

b 父类的引用指向子类的对象

方法重载
a 同一个类
b 方法名相同
c 参数列表不同
1 参数个数不同
2 参数类型不同
3 参数列表顺序不同
d 返回值类型可以不同

e 访问修饰符可以不同

方法重写
a 发生在子父类
b 方法名必须相同 &&
参数列表必须相同&&
返回值类型必须相同
c 可见性不能变小

d 异常不能抛大

引用数据类型转换
a 先试用instance 识别
b 子类隐式的扩展到父类

c 父类显式的缩小到子类

误区：子类虽然比父类方法更多，属性更多，但是终究是属于父类所以比父类小。

静态变量
a 所有的类实例共享
b 通过类名调用静态变量
c 静态变量属于这个类
 非静态变量属于对象
d 代码加载到内存静态变量就存在
e static变量和实例变量区别
1 static变量每个类而言内存中只有一个能被所有实例共享 
实例变量对于每个类都有一份他们之间互不影响 
2 java虚拟机在加载类过程中为static变量分配内存
实例变量 在加载完类后创建对象时 分配内存
3 static变量存在方法区 实例变量存在堆区

        4 实例变量可以通过类名访问 实例变量只能通过应用类型变量访问

static方法
  a 调用时 类名.方法名();
重点   b 静态方法只能使用静态变量
 静态方法在类加载时就存在了
 非静态变量在对象创建时才存在
 非静态方法可以访问静态变量
c 静态方法没有重写
d 静态方法用来表示某个类特有的功能
不依赖于类的具体实例，也不依赖于他的子类
当前类必须提供实现 静态方法属于类

e 不能使用this super关键字

静态初始化块 
在类加载时只执行一次
对于静态变量初始化，当java虚拟机加载类时会执行该代码块

被static修饰的成员变量和成员方法表明归某个子类所有，

         他不依赖于子类的特定实例 被类的所有实例共享 只要这个类被加载

Java虚拟机根据类名运行时数据区的方法区内定位到他们

普通初始化

每创建一个对象都会调用的 对非静态变量初始化

单例模式 整个运行过程中某一个类只能够有一个对象

class Singler{private static Singler singler;//懒汉式//饿汉式private static Singler singler = new Singler();

private Singler(){}//静态  只会创建一次//只有唯一的getInstance方法创建public static Singler getInstance(){if(singler==null){singler = new Singler();}return singler;}}public class SinglerTest{public static void main(String[] args) {    Singler singler = Singler.getInstance();System.out.println(singler);}}

final 
1 修饰变量 变常量 必须初始化 不允许改变 
2 修饰方法 该方法不能被重写

3 修饰类该类不能被继承

抽象类
1 抽象方法
作用：定义了一个规范
如果一个方法没有实现就必须定义成抽象方法

抽象方法描写具体有什么功能但不实现

        2 抽象类

a 如果一个方法有抽象方法就必须定义为抽象类 但是抽象类不一定有抽象方法
b 抽象类也可以包含非抽象方法
c 抽象类可以定义实例变量
d 抽象类可以定义构造器 没有抽象构造方法 也没有抽象静态方法
e 抽象类可以包含多个抽象方法
f 抽象类的作用是提供给其他的子类所有抽象方法
 或者将子类定义成抽象类
g 抽象类不能被实例化 构造器给创建子类对象用的
h 抽象类及抽象方法不能被finally修饰符修饰

3 作用 

             当不知方法的具体实现可以定义为抽象类让子类去实现该方法完成自己的事项

接口 1 定义规范的
2 解决多重继承问题
a 接口是抽象类的抽象 接口中只有抽象方法 而抽象类中有非抽象方法
b 接口中 默认public abstract类型
c 接口中成员变量默认是public static final 必须被显示初始化
d 接口中只能包含public static final和public abstract 成员方法
e 接口中没有构造方法不能被实例化
f 接口可以继承多个接口
g 一个类只能继承一个直接的父类，但能实现多个接口

h 接口告诉程序员该做什么事 定义规范 描述功能

接口和抽象类比较
相同点
1 都不能被实例化   2 都能包含抽象方法
不同点

1 抽象类中部分方法提供默认的实现，从而避免子类中重复实现，

              提高代码可用性

2 一个类只能继承一个父类 但是一个类可以实现多个接口

修饰符的一些小知识

    同类同包    子类  其他类
public y        yy       y
protect y        yy
默认   y   y
private y


基本数据类型包装类
a  Integer i = new Integer(10);
b  i = Integer.valueOf(10);
拆箱
int a = i.intValue();
重点

String --》int  parseInt(String s);

parseInt parseInt parseInt 重要的方法打三遍！

内部类
作用：
  1)可以避免命名冲突。
  2)定义类的范围从package变成了类。
   在一个类的内部定义的类称为内部类。
  3)进行再一次的封装

  4)分担外围类的功能

a) 静态内部类:用static修饰,相当于静态方法。放在方法外，类里面的。
静态内部类具有以下特点：
1)静态内部类可以直接访问外部类的静态资源。
  如果静态内部类中的变量名字和外围类的变量名字
  相同，需要指定访问时的谁的名字。
2)静态内部类如果访问外部类的实例成员，
  就必须通过外部类的实例去访问。
3)静态内部类的实例不会自动持有外部类
  的特定实例的引用，
  在创建静态内部类的实例时，
  不必创建外部类的实例。                 
4)在静态内部类中可以定义静态成员和实例成员。
5)外围类可以通过完整的类名直接访
  问静态内部类的静态成员。
6)外围类可以通过内部类对象
调用静态内部类对象的非静态成员。
7)在静态内部类中和外围类中创建静态内部类的对象.
  静态内部类类名 m=new 静态内部类类名();
  在其他类中创建静态内部类的对象:
    外围类.静态内部类类名 m= 
      new 外围类.静态内部类类名();


b)实例内部类：没有static修饰符。相当于成员变量。放在方法外，类里面的。
特点：
1)在内部类中,可以直接访问外部类的所有资源(属性和方法)。
2)成员内部类不能定义静态的资源，
  只能定义非静态的资源。
3)外围类不能直接访问成员内部类的资源.
   先创建成员内部类的对象，
   在通过调用非静态资源(对象.资源)
4)在成员内部类中和外围类中创建成员内部类的对象
  成员内部类中:类名 m=new 成员内部类类名();
  外围类中:类名 m=this.new 成员内部类类名();
  在其他类中创建成员内部类的对象:
  外围类.成员内部类类名 m=new 外围类().new 成员内部类类名();
5)在创建实例内部类的实例时,外部类的实例必须已经存在。
6)在成员内部类中调用外围类中同名资源:
              外围类.this.资源
7)如果实例内部类B与外部类A包含同名的成员，那么在类B中，this.v表示类B的成员， A.this.v表示类A的成员
8)实例内部类的实例自动持有外部类的实例的引用。
9)外部类实例与内部类实例之间是一对多的关系，
  一个内部类实例只会引用一个外部类实例，
  而一个外部类实例对应零个或多个内部类实例。


c) 局部内部类:在一个方法中定义的内部类，它的可见范围是当前方法。和局部变量一样。     
特点：
1)局部内部类只能在当前方法中使用。
2)局部内部类和实例内部类一样，不能包含静态成员。
3)在局部内部类中定义的内部类也不能被public、protected和private这些访问控制修饰符以及static修饰;
4)可以访问外部类的所有成员，
5)局部内部类还可以访问所在方法中的final类型的局部变量。
  final延长局部变量的生命周期


d)匿名内部类：在一个方法中定义的内部类，它的可见范围是当前方法。和局部变量一样
特点：
1)没有类名，使用接口或者抽象类代替类名
2)访问外围类的一切资源(方法和属性)
3)访问该方法final修饰的局部变量
4)放在方法中或者作为参数。


几种内部类的区别：
 1. 创建
 a. 声明的位置: 
   静态内部类：类的内部，方法的外部，用static关键字修饰；
   实例内部类：类的内部，方法的外部，不用static关键字修饰；
   局部内部类：方法的内部；
   匿名内部类：既可以在类的内部，方法的外部，也可以在方法的内部；
                      
 b. 实例化方式:
    静态内部类：new Outer.Inner();          //在外部类外创建；
              new Inner();                //在外部类内内部类外创建
    实例内部类：new Outer().new Inner();      //在外部类外创建；
              this.new Inner();             //在外部类内内部类外创建 
    局部内部类：new Inner();                  //只能在方法内部创建
    匿名内部类：new 类名() {};            
         
2. 访问
  a. 外部类访问内部类：
    静态内部类：通过完整的类名直接访问静态内部类的静态成员;
    实例内部类：通过内部类的实例去访问内部类的成员;
    局部内部类：不能访问；
    匿名内部类：不能访问；
  b. 内部类访问外部类：
    静态内部类：直接访问外部类的静态成员；
    实例内部类：可以直接访问外部类的所有成员;
         如果实例内部类B与外部类A包含同名的成员，那么在类B中， this.v表示类B的成员，
                A.this.v表示类A的成员。
    局部内部类：可以直接访问外部类的所有成员, 
               访问所在方法中的final类型的参数和变量；
    匿名内部类：可以直接访问外部类的所有成员, 

              访问所在方法中的final类型的参数和变量；

  

集合 java.util
  collection
    Set 不可重复无顺序
 HashSet检索效率最高的 哈希算法保存
 SortedSet 定义在Set基础上的排序的规范
Treeset实现排序规则
List 可重复有顺序 
 LinkedList 使用链表实现list接口
 Vector 使用数组实现List接口 线程安全
 ArrayList 使用数组实现List接口 线程不安全


Map保存键值对 key  value（key不可以重复 value可以）
    HashMap线程不安全 效率高 HAshMap允许key，value都为null
HashTable 线程安全 不允许null
SortedMap定义在map基础上进行排序的规范

  TreeMap 对map进行排序

增强for循环
for(type element:array){}
type:数组或集合中的数据类型
element：临时变量
array：数组或集合的引用

注意：：增强for循环必须实现Iterable接口不能明确指出下标

Set 先比较hashcode值如果不等之接返回不等。不会用equals
TreeSet TreeMap排序
    a 自然排序 在所需要排序的类实现Comparable
        重写compareTo方法
    b 覆盖排序 创建静态内部类实现Comparator 重写compare方法 在创建集合对象时加入
         覆盖排序高于自然排序
迭代器

Iterator iter = list.iterator();while(iter.hasNext()){System.out.println(iter.next);}

Map
put(key,value)  添加数据
keySet()    将Map中所有key取出放入set
get（key）  从map集合中获取数据
entrySet 将Map中所有value重新构建成新的对象（key，value）放在set中
values（）  将map中所有value取出放在collection中
String 不可变长字符串 
StringBuilder 可变长字符串 线程不安全
StringBuffer  可变长字符串 线程安全
泛型
   a 检查数据类型将错误控制在编译器
   b 不需要强制类型转换
  类型擦除 只是在编译期挡住非法输入，
  编译产生的字节码会擦除泛型类型信息

//两个泛型类参数public class TwoGeneric<K,V> {private K key;private V value;public TwoGeneric (){}public TwoGeneric(K key,V value){this.key=key;this.value = value;}public K getKey() {return key;}public V getValue() {return value;}public void setValue(V value){this.value = value;}public static void main(String[] args) {TwoGeneric<Integer,String> t = new TwoGeneric<>(1000,"briup");Integer key = t.getKey();String value = t.getValue();System.out.println(key +":"+value);}}  

properties 查看信息
Properties p = System.getProperties();
p.list(System.out);
设置系统参数 -D
读取文件信息

pro.load(new FileInputStream(new File("")))

反射 java.lang    java.lang.reflect
获得类景象
Class.forName(String className);
实例化对象
Object obj = 类景象对象.newInstance();
默认调用class类的无参构造器
    调用方法需要使用invoke
setAccessible(true)设置属性可见
反射用途
1 修改私有属性的值
2 调用任何对象的任何方法

3 不通过new方式创建对象

异常 
    异常时改变程序正常执行流程的意外情况
    异常的条件都是应用级别异常

try{//会发生异常的代码}catch(Exception e ){//捕捉异常 异常类型//捕获异常后的处理 }finally{//无论发生异常与否都要执行的代码}

throws Exception

 

uncheck异常 runtimeException以及子类异常

check 异常 编译期异常

自定义异常 

  项目中的异常应该抛出有用的信息给用户

throws 方法声明是抛出异常

throw  方法体中抛出异常

getMessage()返回该异常的详细描述字符串

printStackTrack（）将该异常的追踪栈信息输出到标准输出

断言 assert 
如果条件为true 会执行代码
false 则会抛出异常 并输出内容
 断言默认关闭  打开断言需要输入vm参数 -ea

 方法调用递归 很可能造成栈区锁定 尽量少用

 GUI容器 Window 和他的子类JFrame
window是不依赖其他容器而独立存在的容器
Frame 带标题可以调整大小
Dialog 可以被移动 不能被改变大小
setVisible(true)设置为可见
panel不能单独存在只能存在于容器中
getContentpane()
选择布局管理器
setLayout(new )
取消布局管理器
setLayout(null);
FlowLayout  流式
BorderLayout 上下左右中
GridLayout 网格
CardLayout  卡片
JTextField 单行文本
JButton  按钮
JLabel  显示文本 或者图片
弹出一个提示框
JOptionPane.showMessageDiolog(null,"请输入非空数据")
addActionListener 添加点击事件
keyListener 键盘事件
mouseListener 鼠标事件
keyAdapter 
 1 事件源
 2 事件对象 对事件进行描述可以描述事件源
 3 事件监听器 接口提供调用者实现完成事件处理代码
JMenuBar菜单条
JMenu菜单
JMenuItem菜单项
定时器Timer
new Timer(间隔时间，监听器对象) 1000 一秒 ActionListener

每隔一段时间处理一段代码