大三Java SE基础学习笔记
Java及Java SE学习笔记
前言
主要用于记录学习过程中的一些笔记。
了解
JavaEE是指Java Enterprise Edition，Java企业版，多用于企业级开发，包括web开发等等，也叫J2EE
JavaSE通常是指Java Standard Edition，Java标准版，就是一般Java程序的开发就可以(如桌面程序)，可以看作是JavaEE的子集
java是一门程序设计语言，而JavaSe只是一个使用java进行编程的规范、框架，它不是一门编程语言。JavaSe（java standard edition），
一般包括jdk、jre以及各种API文档等：
javaEE 号称有十三种核心技术。它们分别是：JDBC、JNDI、EJB、RMI、Servlet、JSP、XML、JMS、Java IDL、JTS、JTA、JavaMail和JAF
JDK、JRE、JVM
JDK : Java Development Kit
JRE : Java Runtime Environment
JVM : JAVA Virtual Machine
JDK包含JRE
JRE包含JVM
生成文档注释
javadoc -encoding UTF-8 -charset UTF-8 Hello.java
idea快捷键
sout =System.out.println();
psvm=public static void main(String[] args) {
}
fori :快速生成初始值i=0的for循环
快速新建对象：new Student() 后面 Alt+Enter
快速输出test : test.sout=System.out.println(test);
快速生成捕获异常：ctrl+alt+T
alt +insert : 自动生成构造函数
Ctrl+D //复制当前行到下一行
alt复制：复制竖下来的一列
文档注释： /**+回车
数据类型
byte占1个字节范围: -128-127
short占2个字节范围:-32768-32767
位(bit) :是计算机内部数据储存的最小单位，11001100是-个八位二进制数
字节(byte) :是计算机中数据处理的基本单位，习惯上用大写B来表示
1B (byte,字节) = 8bit (位)
1bit表示1位,
1Byte表示一个字节1B=8b
1024B=1KB
1024KB= 1 M
1024M=1G
**最好完全避免使用浮点数进行比较
float 接近但不等于 有舍入误差
**
如果我们需要精确计算的结果，则必须使用BigDecimal类来操作
数据类型等级
低->高 自然转换
高->低 需要强制转换
例如
char c='a';
int d=c+1;
system.out.println(d) //输出为98(不需要强制转换)
system.out.println((char)d) //输出为b (需要强制转换)
转换的时候可能存在内存溢出或精度问题
变量
类变量：也叫做静态变量。static int a=0; 必须初始化和声明，写在方法外，类里面
他是在类里面定义的，所有方法都能访问的变量，类似于全局变量。使用static 修饰的就是类方法（也叫静态方法）静态方法是属于整个类的。
局部变量：写在方法里的
实例变量：写在方法外，类里面，从属于类(必须new才能使用)
命名规范
类成员变量:首字母小写和驼峰原则: monthSalary除了第一个单词以外，后面的单词首字母大写
局部变量:首字母小写和驼峰原则
常量:大写字母和下划线: MAX _VALUE
类名:首字母大写和驼峰原则: Man, GoodMan
方法名:首字母小写和驼峰原则: run(), runRun()
操作数++与–
例如 int a=3,d=2;
int b=a++; //a先赋值再加1 (b=3,a=4)
int c=++d; //d先加1再赋值(d=3,c=3)
包机制
一般利用公司域名倒置作为包名; www.baidu.com com.baidu.www
Scanner对象
Scanner scanner=new Scanner(System.in); 创建输入对象
判断是否还有下一个数
scanner.hasNextInt()
一般常用于while(scanner.hasNextInt())循环判断
接受用户输入
String str3=scanner.nextLine(); //nextLine以Enter为结束符
String str=scanner.next(); // next()不能得到有空格的字符串,自动去掉字符之前的空白
例题
打印三角型五行
for (int i = 1; i <= 5; i++) {
for(int j=5;j>=i;j--){
System.out.print(" ");
}
for(int j=1;j<=i;j++){
System.out.print("*");
}
for(int j=1;j<i;j++){
System.out.print("*");
}
System.out.println();
}
值传递和引用传递
java都是值传递
方法的重载
在一个类中，函数名可以相同，但形参不同
规则：
方法名必须相同。
参数列表必须不同（个数不同，或类型不同、参数排列顺序不同）
可变参数
public void test(int... i) {
System.out.println(i[1]);
}
传进去的本质是数组
必须在最后面
数组
动态初始化
声明数组并创建数组赋予空间
int[] nums=new int[10]; //定义数组
int[] array=null (放在java中的栈中)
array=new int[10] (放在java的堆中)
静态初始化
int [] a={1,2,3,4,5}
数组对象本身是在堆中的
数组也是对象，数组元素相当于对象的成员变量
冒泡排序
时间复杂度为O(n2)
public static int[] sort_maopao(int [] array){
int temp=0;
for (int i = 0; i <array.length-1 ; i++) {
//两两比较次数比数组中的元素少一
//内层循环交换数字
for (int j = 0; j <array.length-1-i ; j++) {
if(array[j+1]>array[j]){
//if里面是+1 所以循环中要-1保证不溢出 如果符号为< 则从小到大排
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
return array;
}
面向对象
本质：以类的方式组织代码，以对象的组织（封装）数据
三大特性：封装，继承，多态
总结：对象是通过引用来操作的：栈–>堆 （真实地址在堆中）
封装
我们程序设计要追求“高内聚,低耦合" 。
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;
低耦合:仅暴露少量的方法给外部使用。
继承
如果父类被final修饰，则子类不能继承此类
super
调用父类的构造方法，必须在构造方法的第一个
只能出现在子类的方法或构造方法中
super 和 this 不能同时调用构造方法
与 this比较：
- 代表对象不同：
this: 本身调用者这个对象
super: 代表父类对象的引用 - 前提：
this: 没有继承也可以用
super: 只有在继承条件在可以使用 - 调用构造方法：
this: 调用本类的构造方法
super: 调用父类的构造方法
重写
需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小（public>protected>private）子类方法为public父类方法为private
4.抛出的异常范围可以被缩小但不能扩大（父类异常为Exception子类异常为ClassNotFoundException）
5.返回的参数类型必须相同
不能重写的方法
1.static 方法，属于类，不属于实例
2.final 常量
3.private 方法
为什么需要重写：
1.父类的东西子类不一定需要
多态
多态是在重写的基础上
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。让程序变得更灵活
存在条件
1.有继承关系
2.子类重写父类方法
3.父类引用指向子类对象（Person person =new Student()）
匿名代码块与静态代码块
{
//跟对象同时产生，在构造方法之前执行
System.out.println("匿名代码块");
}
static {
//跟程序同时产生//最先执行，只执行一次
System.out.println("静态代码块");
}
抽象类
abstract定义抽象类
1.抽象类中可以写普通方法，但抽象方法一定要写在抽象类中。
2.不能new这个抽象类，只能靠子类去实现它。
3.在抽象类中是可以使用构造函数的
接口
接口中所有定义都是抽象的public
作用：
1.作为约束
2.定义一些方法，让不同的人实现
3.implements可以实现多个接口
4.实现了接口的类，必须重写接口中的方法
内部类
1.成员内部类
2.局部内部类(在方法里定义的类)
3.静态内部类
4.匿名内部类(重点)–详情参见多线程笔记。
HashMap数据结构
JDK1.7:数组+链表
JDK1.8:hash表=数组+链表+红黑树
那为什么要在链表长度大于等于8的时候费成红黑树呢?
如果链表的长度没有达到这个长度的话，因为红黑树它自身的这种维护，插入的这种维护的开销也是非常大的，因为每次一去插入一个元素的时候很有可能会破坏掉他的平衡。也就是说hashmap的put操作非常多的时候，可能会影响插入的性能。
为什么数组的长度必须是2的指数次幂?
HashMap为了实现存取高效，要尽量减少碰撞，就是要尽量做到:把数据分配均匀,
负载因子为什么是0.75?
当负载因子不定为0.75的时候(两种情况)
当负载因子定为1时：结论:所以当加载因子比较大的时候:节省空间资源，耗费时间资源
当负载因子定为0.5时：结论:所以当加载因子比较小的时候:节省时间资源，耗费空间资源
但是我们设计程序的时候肯定是会在空间以及时间.上做平衡，所以就选择了0.75这个中间值值,
异常机制
throws用在方法上
throw new Exception(); 用在方法内
异常总接口：Throwable
JVM错误：
StackOverFlow （栈溢出）
OutOfMenory（java内存溢出，不断创建新对象）
自定义异常：继承Exception类即可
常用类
包装类：
自动装箱和拆箱（针对八大基本类型做出的类）包装类均位于java.lang包
在进行基本数据类型和对应的包装类转换时，系统将自动进行。
自动装箱：将 基本数据类型 封装为对象类型，来符合java的面向对象的思想。
自动拆箱：将对象重新转化为基本数据类型。
//包装类测试
//缓存值范围 int：-128～127
public class Test1 {
public static void main(String[] args) {
Integer num1 = 200;
Integer num2 = 200;
System.out.println("num1==num2: "+(num1==num2)); //IntegerCache 不存在此对象，将创建新对象，所以不相等
//相当于编译器执行了Integer num1 = Integer.valueOf(200)操作。
// 这个方法就是返回一个 Integer 对象，只是在返回之前，看作了一个判断，
// 判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，
// 如果存在，则直接返回引用，否则，创建一个新的对象
Integer num3 = 100;
Integer num4 = 100;
System.out.println("num3==num4: "+(num3==num4)); //IntegerCache 存在此对象，返回引用 所以相等
}
}
总览：
集合框架
HashMap原理：
详情请见
https://jingyan.baidu.com/article/ceb9fb10157a18ccac2ba05b.html
IO流
1.Java中Int与Integer的区别？
一、int 是基本类型，直接存数值；而integer引用数据类型。
二、Int的声明不需要实例化，且变量声明后的初始值为0；Integer的是一个类，初始值为null，需要进行实例化，才能对变量数据进行处理。
三、Integer类是int的包装类，实际开发中Integer被看成一个对象，可以进行数据转换等操作。
2.明确equal方法与==的区别
List item equals() 比较的是**两个对象的值（内容）是否相同。
List item “==” 比较的是两个对象的引用（内存地址）**是否相同，也用来比较两个基本数据类型的变量值是否相等。
3.native、volatile关键字
native关键字:
是与C++联合开发的时候用的！java自己开发不用的！一 个native方法就是一个Java调用非Java代码的接口。一个native方法是指该方法的实现由非Java语言实现，比如用C或C++实现.
volatile关键字:
保证了变量的可见性（visibility）。被volatile关键字修饰的变量，如果值发生了变更，其他线程立马可见，避免出现脏读的现象。就是说线程能够自动发现 volatile 变量的最新值。
4.Set集合和List集合区别
它们有一个功共同的父接口，叫 Collection。
区别：
1：Set 里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象，List 以特定次序来持有元素，可有重复元素。
2： List 表示有先后顺序的集合，注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用 add(Obj e)方法时
总结：List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。另外：在set集合中，hashset 集合比较两个对象是否相等，首先看hashcode 方法是否相等，然后看 equals 方法是否相等。new 两个 Student 插入到 HashSet中，看 HashSet 的 size，实现 hashcode 和 equals 方法后再看 size。
5.单例模式、工厂模式、代理模式、装饰模式
设计模式使人们可以更加简单方便的复用成功的设计和体系结构
工厂模式：
模式中的角色和职责
工厂（Factory）角色：简单工厂模式的核心，它负责实现创建所有实例
的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
抽象产品（AbstractProduct）角色：简单工厂模式所创建的所有对象的
父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：简单工厂模式所创建的具体实例
对象。
优点：
- 实现了对象创建和使用的分离。
- 不需要记住具体类名，记住参数即可，减少使用者记忆量。
缺点：
4. 对工厂类职责过重，一旦不能工作，系统受到影响。
5. 增加系统中类的个数，复杂度和理解度增加
单例模式
保证一个类在内存中的对象唯一性。
1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。
好处：
对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销
由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短GC停顿时间
装饰模式
- 对一组对象的功能进行增强时，就可以使用该模式进行问题的解决，是一种对象结构型模式。装饰和继承都能实现一样的特点：进行功能的扩展增强。 但是只为提高功能，进行的继承，会导致继承体系越来越臃肿，不够灵活
- 与继承关系相比，关联关系的主要优势在于不会破坏类的封装性，而且继承是一种耦合度较大的静态关系，无法在程序运行时动态扩展。在软件开发阶段，关联关系虽然不会比继承关系减少编码量，但是到了软件维护阶段，由于关联关系使系统耦合性不高，因此使得系统更加容易维护。当然，关联关系的缺点是比继承关系要创建更多的对象。