Java基础总结

1.     java语言概述

        Java是SUN公司（斯坦福大学网络公司）1995年推出的一门高级编程语言; 2009年SUN公司被Oracle公司收购;

        Java技术分为三个版本: JavaSE, JavaEE, JavaME;

2.     java语言的特点

        ①  面向对象(封装、继承、多态)

        ②  跨平台(一次编写，处处运行)

        ③  解释执行:

            解释执行的含义是，Java程序编译之后，只是生成了class文件，称为字节码，并不是机器码。

            在执行时，JVM中的解释器，会根据当前平台的特征，对class文件进行解释，生成符合当前规范的机器码，得以运行。

        ④  自动垃圾回收

        ⑤  鲁棒,支持多线程,简单性

3.     java变量

        写程序就是在做内存存取，先把数据存入内存，需要的时候取出来做处理。

        内存地址不好记时,我们给他起个别名,这就是变量;

        变量就是数据存储空间的表示;

        变量名:不能以数字开头,其余可以是数字,字母,下划线,$;避开关键字

4.     java关键字

        53个关键字（含2个保留字）;

        数据类型(8)

        boolean  char byte  short  int long  float  double

        流程控制(14)

        if else  do  while for  switch  case default  break  continue return

        true  false  null

        修饰符(13)

        package  import  public  protected  private void  final   static  abstract

        synchronized  class interface  enum 

        操作类(11)          

        new extends  implements  this super  instanceof 

        try  catch  finally throw  throws

        其它(5)

        assert  strictfp  transient  volatile  native

        保留字(2)

         goto const

        描述

            1）.     assert断言, 用于对程序进行调试的;assert需要自行开启且不具有继承性;

                    语法:assert +语句（boolean）：”自定义抛出的错误”；

                    trycatch的异常不能是exception，而是error，AssertionError

            2）.     strictfp, 即 strictfloat point (精确浮点), 可应用于类、接口或方法

                    作用: 初始设定值和代码，都将严格地进行计算

            3）.     transient 短暂 成员变量被修饰后,保存到本地磁盘时,不会被写入

            4）.     volatile挥发不确定性

                    volatile在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，

                    因此volatile变量是一种比sychronized关键字更轻量级的同步机制;

                在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题;可见性靠volatile,                     synchronized,lock ;指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

                    单线程下CPU从内存读取数据, 拷贝变量到CPU缓存中,再进行操作;多线程下,会拷贝到多个CPU缓存中,

                    多个操作;而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，

                    跳过 CPU cache 这一步,保证了公共变量的一致性;

                    一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义(无原子性)：

                    ①保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，

                    这新值对其他线程来说是立即可见的。

                    ②禁止进行指令重排序

            5）.   native native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，

                    而是在用其他语言（如C和C++）实现的文件中。Java语言本身不能对操作系统底层进行访问和操作，

                    但是可以通过JNI接口调用其他语言来实现对底层的访问。

5.     内存堆栈

6.     Java环境

JDK=JRE+开发工具

JRE=JVM+核心类库

7.     数据类型

分为基本数据类型和引用数据类型;

除了8大基本数据类型,其他都是引用类型;

8.     二进制

①计算机的定点数有3种表示法：原码、反码和补码 ;

[原码]即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

[反码]正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

[补码]正数的补码与其原码相同；负数的补码是在其反码的末位加1。

由于原码做减法的值是不对的,所以引进了补码,计算机显示的都是补码;

②上面的位表示的是二进制的位数;,一个字节8位;

③byte范围

机器码=补码(每位都计算):10000000-01111111

原码: 10000000-01111111此时原码和补码恰好一样

-128-127

例如-129-127的机器码:11111111–01111111

                          原码:10000001–01111111

9.     基本数据类型转化

大转小,强转,丢失精度,如double转int 19.7转19

小转大，自动；

10.  数组

存储相同数据类型的一组数据

语法：3种

int[ ] score = new int[ 3];

int[ ] score = new int[ ]{66, 77,88};

int[ ] score = {66, 77, 88};

可以使用length 属性获取数组的大小。

//二维数组

int [][] two1=new int[2][3];//3不写不报错，但是查看长度，空指针

System.out.println(“two1.length:”+two1.length+”,two1[0].length:”+two1[0].length);

int [][] two2=new int[][]{};//这种格式可以不写长度

System.out.println(“two2.length:”+two2.length);

11.  类与对象

类是创建对象的模板, 对象是类的实例化结果;

程序代码操作的是对象而非类,建模得到的是类而非对象;

方法的定义:方法类型+方法签名(方法名+参数列表)+方法体

Java方法调用参数传递采用值传递方式;

被回收的对象是：不再被任何变量引用的,引用变量自动放弃,人为将引用变量置为null

面向对象的三大特性:封装继承多态

12.  封装

就是隐藏对象的属性和实现细节,仅对外提供公共访问方式,封装的好处:隐藏类的实现细节;让使用者只能通过程序员规定的方法来访问数据;可以方便的加入存取控制语句,限制不合理操作.

修饰符     当前类    同 包       子 类       其他包

public        √    √    √    √

protected √    √    √    ×

default      √    √    ×    ×

private      √    ×    ×    ×

Protected不同包中必须是子类才能调用;

13.  继承

是基于已存在的类来构建新类;

实现代码重用的重要手段之一,体现不同抽象层次;

java中只支持单继承

14.  多态

多态性是指同一操作作用于某一类对象，可以有不同的解释，产生不同的执行结果。

消除了类型之间的耦合关系

多态的存在提高了程序的扩展性和后期的可维护性,多态

15.  重写与重载

override（重写）

1)方法名、参数相同,返回值相同。

2)存在于父类和子类之间,是父类与子类之间多态性的表现

3)方法被定义为final不能被重写,子类中必须重写父类中的abstract方法

4)子类方法不能缩小父类方法的访问权限,不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

overload（重载）

1)参数类型、个数、顺序至少有一个不相同,返回类型可以相同也可以不同;

2)存在于父类和子类、同类中,同一个类中多态性的表现;

3)不能重载只有返回值不同的方法名。

16.  类的转型

向上转型:由子类转型成父类，在继承图上是向上移动的，安全

向下转型: 不安全（可能需要instanceof操作符协助）

17.  抽象类与接口

抽象是把多个事物的共性的内容抽取出来;

含有抽象方法的类或者用abstract修饰的类我们称之为抽象类。

接口比抽象类更加抽象;

相同:

都不能实例化,方法必须全部实现

区别:

抽象类可以有普通方法和抽象方法,接口只能有抽象方法;

抽象类可以多种修饰符,接口只能public;

抽象类可以定义变量,接口的只能是常量;

18.  String

String对象一旦创建就不能改变

StringBuffer线程安全的可变字符序列,一个类似于String的字符串缓冲区;

StringBuilder由于它不执行同步，所以速度更快,不安全;

StringBuilder>StringBuffer>String

19.  内部类

将一个类定义在另一个类的内部类称之为内部类。

特点: 实现隐藏, 直接访问外部类的所有成员,

外部类不能直接访问内部类,间接地去实现多继承;

         分为四大类:成员内部类,静态内部类,匿名内部类,局部内部类

         成员内部类：(不能有static)

访问外部成员, Outer.this.id;

创建实例: Outerouter = new Outer();

 Outer.Inner inner = outer.new Inner();

         静态内部类：

使用static修饰的成员内部类叫静态内部类；

静态内部类可以看做是与外部类平级的类。

不能访问外部非静态成员；

创建实例：Outer.StaticInnerstaticInner = new Outer.StaticInner();

局部内部类：

          定义在代码块、方法体内、作用域；

访问外部成员, Outer.this.id;

只能在作用域内实例化，外部无法调用；

          访问作用域内的局部变量，该局部变量需要使用final修饰

匿名内部类：

没有名称的内部类，没办法引用它们。必须在创建时，作为new语句的一部分来声明并创建它们的实例；

匿名内部类语法：new  interface/superclass()  {  //类体 }

这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口，并同时创建该匿名类的一个新实例。

20.  自动装箱和拆箱

同样的动作适用于 boolean、byte、short、char、long、float、double等基本数据类型，分别使用对应的包装类型(Wrapper Types)Boolean、Byte、Short、Character、Long、Float、Double；

1.     当-128-127时数字自动装箱是一样的，范围外是不一样的；

2.     使用==时不同类型是不能比较的，除非有运算符参与

Integer a = 1;Integer b = 2; Integer c = 3;Long g = 3L;

g == c无法编译；

g == (a+b) 成功；

21.  equals和==

“==”：如果是基本数据类型，则直接对值进行比较，如果是引用数据类型，则是对他们的地址进行比较（但是只能比较相同类型的对象，或者比较父类对象和子类对象。类型不同的两个对象不能使用==）

equals：内容比较；

22.  枚举

enum很像特殊的class；

枚举值都是public static final的，也就是常量；

构造器私有private，不允许有public构造器；

publicenum ChannelNumEnum {

//定义常量

FIVEEIGHTCITY(“42”),

TOUTIAO(“43”),

MISYNDICATED(“44”);

//定义私有变量

private String value;

private ChannelNumEnum(String value) {

          this.value = value;

}

public String getValue() {

          return value;

}

public void setValue(String value) {

          this.value = value;

}

//根据值获取常量

public static ChannelNumEnumgetChannelNum(String value){

          for (ChannelNumEnum channelNum :ChannelNumEnum.values()) {

                  if(channelNum.value.equals(value))return channelNum;

          }

          return null;

}

}

23.  异常

所谓异常是是指在程序运行的过程中发生的一些不正常事件导致程序直接中断；

finally{}不管系统有没有抛出异常都会去执行，一般用来释放资源。除了在之前执行了System.exit(0)；

Error（错误）:

是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。

Exception（异常）:是程序本身可以处理的异常。

Exception这种异常分两大类运行时异常和非运行时异常(编译异常)；

运行时异常：都是RuntimeException类及其子类异常，可以选择捕获处理，也可以不处理；

非运行时异常（编译异常）：是RuntimeException以外的异常

自定义异常：

自定义的异常类，可以自定义参数描述异常信息，需继承exception

class Bar{

public void enter(int age) throws AgeJudgeException{

          if (age < 18) {

                   throw new AgeJudgeException(“年龄小于18，禁止入内”);

          } else {

                   System.out.println(“欢迎光临”);

          }

}

}

24.  集合

Collection

一组”对立”的元素，Iterable迭代器接口是Collection类的父接口,通常这些元素都服从某种规则

1.1)  List有序可重复

包含：ArrayList，Vector，Stack，LinkedList

ArrayList是动态的增长的、允许再分配的Object[]数组；Stack用于模拟”栈”这种数据结构(LIFO后进先出)；LinkedList是双向链表结构，还有队列的特性；

1.2) Set无序不重复, (定义了equals()为唯一性判断的标准)。类似一个罐子；

         包含：HashSet，LinkedHashSet,TreeSet, EnumSet

HashSet根据HashCode值放入，equals()决定是否可以加入HashSet、而hashCode()决定存放的位置，它们两者必须同时满足才能允许一个新元素加入HashSet；LinkedHashSet根据插入顺序放入；

TreeSet是SortedSet接口的实现类，可以确保集合元素处于排序状态，TreeSet采用红黑树的数据结构来存储集合元素而不是hashcode，TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系；HashSet的性能总是比TreeSet好；

1.2)  Queue保持一个队列(先进先出)的顺序

包含：PriorityQueue，Deque

PriorityQueue按照队列元素的大小进行重新排序；Deque的实现类既可以当成队列使用、也可以当成栈使用；

Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用)

Map

一组成对的”键值对”对象;

Map的key不允许重复，key集的存储形式和Set集合完全相同；

HashMap不能保证key-value对的顺序，LinkedHashMap与key-value对的插入顺序一致；

包含：HashMap，TreeMap，HashTable

HashTable的方法是同步的，HashMap是未同步，所以在多线程场合要手动同步HashMap；

HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)；

HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

25.  arraylist和linkedlist的区别

1.     ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机访问数据，ArrayList优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作，LinedList比较占优势，因为ArrayList要移动数据。

1. linkedlist无需维护容量大小,但是新建一个entry;

5.linkedlist迭代器遍历最好,for很差; ArrayList遍历for最好,foreach最差;

分析: 因为ArrayList是使用数组实现的,若要从数组中删除或插入某一个对象，需要移动后段的数组元素，从而会重新调整索引顺序,调整索引顺序会消耗一定的时间，所以速度上就会比LinkedList要慢许多. 相反,LinkedList是使用链表实现的,若要从链表中删除或插入某一个对象,只需要改变前后对象的引用即可!

26.  Awt和Swing

Swing的属性都加上了J;监听不变;

主要属性: JFrame, JLabel, JTextField, JButton, JPanel

监听器：ActionListener, WindowAdapter, MouseAdapter

5种布局管理器：

FlowLayout 流式布局管理器

 BorderLayout边界布局管理器

 GridLayout网格布局管理器

 CardLayout卡片布局管理器

         GridBagLayout网格包布局管理器

27.  Java线程

程序是:安装在磁盘上的一段指令集合;

进程是:运行中的程序，是动态的概念,每个进程有独立的资源空间;

线程是:又称为轻量级进程，是程序执行流的最小单元

一个程序至少有一个进程,一个进程至少有一个线程.

创建线程的方式:

①  继承Thread类, 重写run方法,实例化后调用start方法;

②  实现Runnable接口,实例化后作为构造参数放入实例化Thread对象,并调用start方法;

③  实现Callable接口,重写call方法, 实例化后作为构造参数放入FutureTask对象,再作为构造参数放入实例化Thread对象,并调用start方法;

④  匿名内部类newThread(){抽象类}或newThread(new Runnable(){接口})

实例:bank都取钱400,对方法枷锁后,不能同时取400;

死锁:方法一嵌套两个锁,方法二两个锁顺序相反,相互死锁;

thread与runable的区别：不加锁时runable中的变量共享，thread不共享；

28.  IO流

①  File类使用构造方法读取磁盘文件;

 createNewFile可以创建文件, mkdirs可以创建文件夹;

delete()删除文件或者删除空的文件夹；如果存在文件的文件夹无法删除;

file.list()返回String数组，只是名称遍历;

file.list(FilenameFilter filter)文件名过滤;

file.listFiles()该文件夹中所有文件夹和文件返回file数组，是文件遍历;

②  FileInputStream, FileOutputStream字节写入写出内存;

BufferedInputStream, BufferedOutputStream缓存加速,以上面的为构造参数;

Int data =bis.read()返回int类型(二进制数字); bos.write(data)写入;

③  FileReader, FileWriter,字符写入写出内存;

BufferedReader, BufferedWriter,缓存加速,以上面的为构造参数;

String len = br.readLine();bw.write(len); bw.newLine();一行一行读,需要换行写;

bw.write(字符串),可以直接写字符串;

④  转换流

InputStreamReader(FileInputStream), OutputStreamWriter(FileOutputStream);

⑤  对象ObjectInputStream, ObjectOutputStream

首先对象需要序列化;然后使用ObjectInputStream, ObjectOutputStream进行读写;

ObjectInputStream ois = new ObjectInputStream(newFileInputStream(“d:\student.txt”));

           Student student2 =(Student)ois.readObject();

           Student student3 =(Student)ois.readObject();

⑥  Flush

因为输出流在进行输出时，比如像某个文件中写入内容，其实是先将输出流写入到缓冲区，当缓冲区写满后才将缓冲区的内容输出到文件中。但是当主机完成输出流的输出后，有可能缓冲区这个时候还没有被填满，这样的话，就会一直等待主机发送内容，这时候，就可以使用flush将缓冲区的内容强制输出到文件中，清空缓冲区。所以，一般在关闭输出流之前，要先调用flush方法强制缓冲区中的内容输出，并清空缓冲区;

29.  反射

包含Class, Constructor, Field, Method类; 这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制

1)     Class是Java反射机制的基础,实例的获取有三种方法:

①  Class