Java中的一些基础知识点

本篇博客写的都是上课学习Java的时候所记录的一些笔记(还是比较篇概念的内容)，所以可能内容不是很全面、或许也很杂，内容都是从基础一点点往后增加的。

转载请注明出处：http://blog.csdn.net/a_zhon/

1.数据类型：由低级到高级转型

(byte,char,short)-->int-->float-->long-->double-->boolean
/**
* 类型转换 1.强制类型转换:我就是要这么干 2.自动类型转换:只能从小到大进行，无法逆
* 向,并且具有前后兼容性
*/

2.数据类型所占字节

byte      1字节   8位
char      2字节  16位
short     2字节  16位
int       4字节  32位
float     4字节  32位
long      8字节  64位
double    8字节  64位
boolean          1位

3.二进制:计算机机器计算规则

好处:1.计算方便
2.运算规则简单
3.适合逻辑运算
4.易于进行转换

1.基本数据类型:
byte,char,short,int,float,long,double,boolean
2.引用数据类型: 对象类型
3.数组

堆内存,栈内存的区别:
1.栈内存运行速度快
2.堆内存体积大
3.栈内存主要存放基本数据类型,堆内存主要存放引用数据类型

4. 变量

/**
* 局部变量：
* 定义在方法体内部的属于局部变量,
* 这个变量只能在自身方法体内使用 一旦方法执行完成，
* 局部变量自动销毁(如果方法是静态方法，该局部变量不会销毁) (存放于栈内存中)
* 成员变量: 作用于整个类 (存放于堆内存中)
* 静态变量：作用于整个包
*/

5.运算符

/**
* 加法是把左右两边的数据转换成二进制进行运算
*
* 字符串连接符，不需要进行二进制转换
*
* 字符串和任何数据类型进行连接操作（+），结果都是字符串类型
*/

/**
* j=i++; 先给j赋值。然后在自加1
* j=++i; 先i自加1，然后在给j赋值
*/

/**
* & : 一假为假
* | : 一真为真
* ^ : 相同为假，不同为真
* && : 前面的为真时，后面的不执行
* || : 前面的为真时，后面的不执行
* << : 左移位 运算速率快，但是只能乘以2的n次方 （6<<n）---->n代表2的几次方
* >> : 右移位 运算速率快，但是只能除以2的n次方（这是整形之间的运算，需要取整）
*/

6.选择结构

/**
* switch语句
* 当判断条件满足时，没有break的话会继续执行下一条语句，并且不在进行判断，
* 直到遇到break为止
* 代码先走case 语句 最后走default
*/

7.while循环

/**
* while 循环
*    先判断在执行
* do while
* 不论如何 do while 至少执行一次
*/

8.for循环

//初始表达式只执行一次，执行语句是在条件表达式之后执行。
for(初始表达式 ; 条件表达式 ; 循环后的表达式){
System.out.println("执行语句");
}

9.面向对象

/**
* 使用匿名对象的时候。只有在掉了对象的行为时才有实际意义
* 调用属性没任何意义，并且都会在执行完毕之后被回收
*/

10. 封装

/** 封装：是指隐藏对象的属性实现细节，仅对外提供公共的访问方式
* 特点：
*  1.安全性高
*  2.复用性强
*  3.便于使用
*  4.隔离变化
* 封装的原则：将不需要对外提供的内容隐藏起来，把属性隐藏，提供公共方法让其访问
*/

11.构造函数

/**
* 静态成员变量与非静态成员变量之间的区别：
* 1.存放的位置不同
* 2.生命周期长短不同
* 3.静态成员变量生命周期比非静态成员变量长
* 什么时候使用静态：
* 1.当几个对象之间具体共享的成员的时候
* 2.当几个对像在初始化已经具备某些相同的属性或行为
* 静态的好处：节省内存（单独开辟一个空间，存静态成员），方便使用：类名.静态成员
*   坏处:访问局限性(静态区域只能访问静态成员)
*   ｛
*        构造代码块
*   ｝
*/

//构造代码块：对对象进行初始化，运行在构造函数之前，对象一建立，立即运行，而且只能运行一次。静态代码块优先于构造代码块

12. 继承

子类继承父类，就获得了父类的属性和行为(private除外)
为什么要使用继承： 1.提高代码复用性 2.为了多态的顺利进行
继承的关系是一种特殊的关系   子类 is a 父类
先有父类，再有子类，但是代码中，父类是由多个子类进行抽取得到的。

13.成员变量

super：代表父类的对象
this ：代表本类对象
特殊情况：父类和子类没有同名成员时，使用super和this都是指父类对象
加载子类的.class文件之前会优先加载父类的.class文件

14.成员方法

当子类和父类存在同名方法的时候：重写（覆盖）
这种覆盖不是严格意义上的覆盖，父类的方法在内存中还是存在的，
只不过这时候实例化的是子类对象，只能调用自身方法

重写是为了解决：当子类对象具备和父类相同的功能，
但是功能的内容不同时，我们可以用方法的重写来重新定义子类的功能内容，并且保留了父类的方法定义。
重写：提高了代码的可扩展性

//重写与重载的区别：1.方法的重载只看参数列表    2.重写子类和父类的方法格式必须一模一样

15.构造方法

在子类构造方法中会默认添加一个隐式语句,super();回调父类的构造函数
子类中每个构造函数都调用了一次父类的构造函数super();
为什么Java要这么干：在子类创建对象之前，必须明确父类初始化的内容，防止安全隐患
用了this()，super就不会默认被添加，因为代码最终还是会走super()。
super()必须出现在构造函数的第一行。
this()回调本类空参构造;

16.抽象(abstract)

这个功能不能含有方法体，因为这里面的功能存在很多模糊不清的东西。
特点：abstract能够修饰类和方法，不能够修饰变量
为啥出现抽象：我们抽取的过程中发现很多子类的方法名字相同，但是实现的功能不一样，我们父类无法对其进行描述，因为它是模糊不清的，这个时候我们只抽取方法的名字，没有方法体
特征：1.抽象类不能被实例化，不能用new来创建对象
2.子类继承抽象类，子类必须重写抽象类中所有方法，不重写也行，只不过这时候子类也成了抽象类
3.要想实例化抽象类，必须实例化重写了其所有抽象方法的子类
4.子类要想真实存在，必须重写所有抽象方法，因为抽象类含有强制性
5.抽象类其实和一般类一样，都是从子类向上抽取得到的。

//不同之处在于：1.抽象类一般情况下比一般类要多几个抽象方法（HttpServlet它是一个抽象类，但是它没有抽象方法，这么做唯一的目的就是不让其进行实例化操作）。2.抽象类不能被实例化

17.接口(interface)

方法都是抽象方法
成员格式固定： 成员变量：public static final
成员方法：public abstract
(修饰符可以不写，系统会默认添加)
接口和抽象类一样，不能被实例化，要想实例化接口，必须实例化一个类（实现了该接口）
在JVM中，接口的编译生成的还是.class文件。
不支持多继承的原因：父类可能含有同名方法，会出现安全隐患。但是在多实现过程中，不存这种说法，接口的方法本身就是不具备方法体，是模糊不清的，所以说实现多个接口的类不管到底实现了哪个接口的方法。
Java中可以同时进行实现接口和继承，extends XXX implements XX
接口和接口的关系：继承，可以多继承
特点：
1. 是一种对外暴露的规则
2. 接口是程序功能的扩展
3. 接口可以多继承
4. 接口与接口有继承关系：多继承

18.多态：多种形态 有两种：函数的多态，对象的多态

对象的多态：一种事物的多种表现形态
父类的引用指向了子类的对象
1. 多态提高了代码的扩展性
2. 使用的局限性：不能使用子类特有的方法

19.程序运行会有两个过程：编译过程和运行过程。（动态绑定，静态绑定）

(编译看左边，运行看右边)
非静态方法  编译过程中：查看引用类型变量是否含有该方法
运行过程中：查看引用类型变量指向的对象方法

静态方法       编译过程和运行过程中：查看引用类型变量是否含有该方法

成员变量       编译过程和运行过程中：查看引用类型变量是否含有该变量

20.内部类：一个类定义在另一个类的内部类

访问内部类分两种情况：
1.内部类所在外部类访问
2.外部其他类访问内部类
外部类.内部类  变量名 = 外部类对象.内部类对象
(Outer.Inner in = new Outer().new Inner())
内部类可以访问外部类的所有成员，包括私有成员
不论内部类是否被封装，外部类都能进行访问
内部类的意义：1.为了让内部类对外部类所有成员具有访问权限，
2.可以对内部类进行更好的封装，要想访问内部类对象，必须经过外部类的同意（外部类可以提供一个方法供其它类进行访问）
当被static修饰的时候，可以直接使用外部类.内部类来创建对象。(Outer.Inner in = new Outer.new Inner())   如果内部类中有静态内容，那么该类也必须是静态的
内部类中调用外部类的成员，省略了：外部类.this
作为局部变量存在，只能在当前所在区域内进行调用。不能静态化

匿名内部类其实就是一种简写格式
定义匿名内部类的前提：内部类必须继承一个类或者实现一个接口

21. 进程和线程

进程：是由系统创建的一个活动单元
线程：进程运行的最小单元，是由系统创建
CPU运行线程
线程的状态：
1. 被创建
2. 运行
3. 睡眠
4. 等待
5. 阻塞
6. 销毁

22.实现Runnable的好处，打破了单继承的局限性，强烈使用实现而不使用继承

使用前提：
1. 必须是多个线程
2. 必须使用同一个锁
线程锁（synchronized）
synchronized (obj){  //obj--->锁旗标
共享数据代码块
}

23.确定一个线程是否安全？

1. 找出使用多线程运行代码
2. 是否操作了共享数据
3. 操作共享是否会出现安全问题
同步方法：
因为非静态方法是被对象调用的，所以这个锁就是自己对象本身this
静态方法：JVM首先将.java编译成.class，这时候.class是作为对象存在，所以使用的锁：类名.class
死锁
解决单例模式-->懒汉式线程不安全的方法。
public class Single{
private Single(){}

private static Single lhs = null;

public static Single getInstance(){
if(lhs == null){
synchronized (Single.class){
if(lhs == null){
lhs = new Single();
}
}
}
return lhs;
}
}

24. 线程等待换醒机制

wait(),notify()。必须持有锁
必须同一个锁

线程池：1.存放等待的线程
notify()：一般情况下跑到线程池去唤醒第一个等待的线程
wait(),notify()，notifyAll().这三个方法封装在Object类中的原因：
这三个方法必须持有锁，这个锁是任意对象，在调用过程中，只有Object可以作为任意对象的父类。所以封装在Object类中，可以被任意锁调用

25.线程中的Interrupt()方法

wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻。

调用Interrupt()方法则其中断状态将被清除，它还将收到一个 InterruptedException。
//join();加入，优先执行，A线程加入B线程，优先执行A线程，A线程执行完毕，执行B线程，与除AB外其他线程无关。

26.String解析(类类型)

String str = "abc";//这样写是在常量池中开辟一个空间
String对象有一个特性：不可变(指的是对象)，赋值操作是针对该对象的引用进行的，让该对象的引用指向其他内存地址

String str1 = "abc";
String str2 = new String("abc");
//区别：第一句：创建了一个对象
第二句：创建了两个对象
equals()在String中对Object的方法进行了重写，比较的是字符序列

27.集合

1. 集合可以存储不同类型的数据
2. 集合长度可变
3. 集合用来存储对象，对象是用来存储数据
4. 集合里面存放的都是对象的地址
List:它是有序的，可重复的，因为他有索引
ArrayList：底层是数组结构，查询快，增删慢，它是线程不同步的
LinkedList：底层是链表结构，查询慢，增删快
Vector：底层是数组结构，它是被淘汰的

TreeSet:底层是树状结构
数据是按字典顺序排列的

28.集合泛型

/**
* 泛型:广泛的类型
* 在编写代码的过程中，使用集合强转的时候可能会出现ClassCastException(类型转换异常)
* 因为在集合中存放的对象是任意的，使用对象的时候会有安全隐患
* JDK1.5之后出现了泛型
* 1.泛型好处在于:将程序运行时的异常转换成编译时的异常
*                方便程序员编写代码，提高代码的安全性
* 2.避免了强转操作
* 泛型的格式:<类型>
* 泛型的使用:在集合中使用的比较多,其实泛型的定义就是指定接收某一类型
*
* 泛型出现之前与出现之后的对比:
* 早期:定义Object去接收未知类型
* 现在:当需要使用的引用数据类型不确定的时候,使用泛型去作为一个规则去接收数据(提高代码的扩展性)
*          一旦这么定义,该类中所有使用到了该泛型的方法都必须遵守这个规则
* 现在我想打破这个规则:
* 1.之前都是泛型类
* 2.可以使用泛型方法打破这个规则
* 当方法需要使用未知类型的引用数据的时候，如果在类上定义泛型，会造成使用的局限性，为了打破这个局限性，
* 我们在方法中单独定义泛型，让该方法使用的泛型脱离类的控制
* 格式:修饰符 <泛型> 返回值 方法名(){}
* 静态方法使用泛型:必须使用自己定义的泛型
*
* 泛型的高级应用:
* 占位符:  ?
* 泛型限定: ? extends Person 定义上限,向下扩展
*      : ? super Person  定义下限，向上延伸
*
*/

29.Map集合

/**
* Map<K,V>:映射,键值对
* 一个映射不能包含重复的键；每个键最多只能映射到一个值
* k--->key
* v--->value
* 1.containsKey(Object key) 查询是否含有该键
* 2.containsValue(Object value) 查询是否含有该值
* 3.get(Object key) 通过键查询值
* 4.put(K key, V value) 添加
* 5.putAll(Map<? extends K,? extends V> m) 添加
* 6.V remove(Object key) 删除映射的同时会拿到该映射的Value值
* 7.Collection<V> values() 拿到由该map中的值所组成的集合
* 8.replace(K key, V value) 修改该映射
*
* 需求，对map的映射进行修改，假设map存在一个映射关系  abc-->学生
*                             将该映射修改为  abc--->老师
*
* Map
* |--HashMap:底层是哈希表，null可以作为键或者值,是线程不同步的(运行效率高)
* |--TreeMap:底层是二叉树结构,会进行一个排序,是线程不同步的(运行效率高)
* |--HashTable:底层是哈希表，null不能作为键或者值,是线程同步的(运行效率低)
*
* 需求:遍历一个HashMap
* 特殊方法:
* 1. Set<K> keySet() 将map中所有的键取出并存入一个set集合中
* 2. Set<Map.Entry<K,V>> entrySet()  将map中的映射关系取出并存入一个set集合中
*    Map.Entry<K,V>指的是一组键值对
*
* map是如何保证唯一性的:通过hashCode()和equals()两个方法同时决定
*
* 需求:有5个学生，将学生的姓名(String name)
* 和地址(String add)存放进map中，形成映射
* 学生有姓名和年龄属性,当姓名和年龄同时相等时，这是同一个学生，不存
*
* 当自己创建的类生成的作为key存放进map的时候，需要重写hashCode()和equals()方法
* 指定规则:什么时候键重复
*/

30. I/O流

/**
* I/O 流:I->Input  O->Output
* I/O流：用于不同设备之间进行数据传输
* 用java书写代码进行的I/O传输
* I/O在java中的体现:存在一个体系:封装在了IO包里面
* 数据传输分为:
* 字节流(数据以字节的形式进行传输):
*
* 字符流(数据以字节的形式进行传输):
* 都是操作文件,文本以字符为主,创造出了字符流
*
* ascII(老美) A - 65  a - 97
*
* 汉字:GB2312编码表(存放了几千个汉字)
* 汉字:GBK编码表(收纳了几万个汉字)
* 汉字:18030编码表(56个名族)
*
* 国际码表:utf-8(unicode)
*
* 字符流是基于字节流:只所以要使用字符流:方便
*
* IO包:有四个基类
* 字节流基类:InputStream,OutputStream
* 字符流基类:Reader,Writer
*
* 会有很多子类:FileInputStream
* (以当前基类名字为后缀,前面的名字代码的是具体的操作对象)
*          FileReader
* (以当前基类名字为后缀,前面的名字代码的是具体的操作对象)
*/
/**
* IO流: new FileWriter(fileName);这个构造方法:
* 假如该文件存在于当前目录下，则新建一个该名字的文件，
* 并且把之前那个文件覆盖掉 不论如何，都会新建一个文件
* 在调用该构造方法的时候:如果指定路径不存在，则会产生FileNotFoundExeception
*/

以上就是在学校复习Java基础知识点时候的一些笔记，大部分还是概念的东西如果感兴趣可以尝试着编写相关代码来验证。