初遇java
首次接触java是在大二上学期的时候，在学校老师讲的很快，再加上本来也没好好听讲，所以基本也没学到什么，为了应付考试和项目自己看过一些书，知道一些很少很少的用法。
一、 开始学习什么是java？
java是一种编程语言
java的优势是什么？
我觉得java的应用范围很广，基本上方方面面都能涉及到，不过目前我学习的是面向网站的javaEE。
JDK版本的选择和安装
越高的版本的JDK功能是越多的，但是对于生产开发，很多应用还用的是旧版的JDK，类似于1.6,1.7，所以在学习时，使用的是JDK1.8.。
IDE的选择
我选择的是myeclipse2019.4.0，老实说我觉得这个版本的界面比我之前上学用的2014好看太多了，所以下下来的时候还是很开心的(不过还是需要吐槽一下，myeclipse启动的太慢了…隔壁朋友的eclipse每次秒启动，我要等好久或者重来好多次)
Java的运行原理
Java源文件(.java)—>(经过编译)—>Java字节码文件(.class)—>交给JVM虚拟机执行，然后交给操作系统执行；正因如此java可以在多种平台上使用。
二、 变量与运算符
变量和运算符的内容很基础，但要牢记
1.命名规则
类名：首字母大写，如：Student，Test
变量名，方法名：首字母小写，后续字母大写(驼峰命名法)，如：stuName，age；getName，getId
包名全部小写
常量名全部大写
不能用关键字和保留字命名
2.变量
常量是一直不变的量；而变量就是在程序运行过程中可变的量。
变量的声明与赋值方法：数据类型 变量名 = 值 | 表达式 |方法；
两个概念：
a.成员变量：成员变量是在类的下一级定义的变量，可以不用赋初值。
b.局部变量：在类的方法中定义的变量，使用前必须赋初值，作用于只能在本方法中。
3.数据类型
8种基本数据类型：byte字节型，short短整型，int整型，long长整型，float double char boolean
引用类型：类，接口，字符换，数组等…
数据类型转换
a.隐式转换：由系统自动转换，类型要相互兼容，小转大；
b.强制转化：当类型不兼容或大转小时，需要由我们自己强制转换double d =12.3；
int t=(int) d；
注意：强制类型转换会有精度损失
4.关系运算符
区分=和==的区别
其他运算符： ！，& ，|， ，/(取模)，*，%(取余)等
三元表达式boolean n = (4 < 3) ? true : false;
？前面的为真，则执行：左边；为假，执行：右边。
三、流程控制语句
这里主要学习了一些流程控制语句
if语句if(条件){
}
switchswitch(n){
case 1：
break；
default：
}
这里要说明的是，case具有贯穿性，所以在使用时，可以根据需求，来判断是否需要些break
能打破switch结构的，只有break和}。
forfor(迭代变量；循环条件；控制循环次数的操作){
}
whilewhile(){
}
while是先判断条件是否成立，再执行的
do…whiledo{
}while()
do…while必定会执行一次，先执行，后判断(先斩后奏)
每个流程控制语句可以相互嵌套，但是不要嵌套过多，以免代码杂乱，逻辑难以理清。
while和do…while常用于次数不明确的循环，for常用语次数明确的循环
死循环并不一定是错的，当要完成某些需求时，可以用到死循环
四、数组
这里学习了数组的使用
数组是引用类型，使用数组前必须实例化
数组的声明
a.
1、声明数组 2、实例化数组int[] nums;
nums= new int [5];
b.
声明同时实例化int [] numbers =new int[5]；
int [] bym2s ={1,2,3,4};
int [] vya3s=new int[ ] {1,2,3,4};
内存：栈 堆 池
程序和变量都在栈中
基本数据类型都放在栈中
数组使用时，先在栈中分配一块空间，用来存储数组元素在堆中存储的地址。
数组的索引都是从0开始的
比如我创建了一个length为5的数组，但是a[5]是取不到的，如果这样写，会提示数组越界。
foreachfor(数组元素类型 变量名 : 数组名){
语句;
}
多维数组
多维数组我的理解就是在一维数组中，将他的元素也变为数组，就成了多维数组
多维数组的创建数据类型 数组名 =new 数据元素类型[行数] [列数]；
//列数可以不写
ex：
int[][] a=new int[3][];
int[][] a=new int[3][4];
数组的操作
a.取数
a[索引] 就可以取出其中的数
b.取数组长
a.length
c.数组的遍历int [] numbers =new int[5]；
for(i=0;i
syso(“number[i]”);
}
//foreach
for(int i : number){
syso(“number[i]”);
}
冒泡排序
{
for(j = 0; j < n-i; j )
{
if(a[ j ] > a[ j 1 ])
{
t = a[ j ];
a[ j ] = a[ j 1 ];
a[ j 1 ] = t;
}
}
}
扩展：
直接插入排序
希尔排序
简单选择排序
方法
方法是可以说是程序里非常重要的一环了，所以在学习中要重点理解，多练习。
什么是方法？
方法是完成某个功能的一组语句，通常将常用的功能写成一个方法。
方法的声明或者定义——方法五要素
访问修饰符，返回值类型，方法名 ， 参数列表，方法体[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…){
方法体
}public void getType(){
}
void 可以写也可以不写 return，写return可以用来结束方法，类似于break
非void必须写返回值，方法的每条分支必须要有return
参数 可以一个可以多个，多个的时候用逗号隔开
参数传递时要注意的问题
值类型参数传递，传递的是值的副本(类似于复制一份传递过去)。
引用类型参数传递， 传递的是对象的地址的副本 所以方法内或方法外操作的都是同一个堆中内容，所以值会改变。
方法的调用
a.实例化类对象类 对象名 =new 类()；
b.调用方法对象名.方法名(有参带参，无参不写);
方法的重载
即相同的事，不同的做法
a.在同一个类中
b.方法名相同
c.参数列表不同(类型，个数。即有一个独一无二的参数列表)
d.和访问修饰符、返回值类型无关(可以相同，也可以不同)
面向对象
面向对象是一个抽象的概念，java就是属于面向对象语言
**抽象：**从事物中舍弃个别的非本质特征，抽取共同的本质特征只考虑与问题域相关的信息，而忽略与问题域不相关的部分
**对象：**万物皆对象，对象有自己的属性和行为(方法)
**类：**对对象的抽象
生活中先有对象再有类，而程序中先有类，类的作用是创建对象，类是生成对象的模板。
如何写一个类？
写类三步走：
1.发现类
2.发现类的属性
3.发现类的方法//1.发现类
public class 类名{
//2.发现属性
访问修饰符 数据类型 属性名 ;
//3.发现方法
访问修饰符 返回值类型 方法名(参数列表){方法体;}
}
对象
a.对象实例化类名 对象名 = new 类名()；
b.给对象的属性赋值对象名.属性=值
c.调用对象方法对象名.方法名(参数);
d.对象在内存中的存储
栈内保存了对象的首地址，即引用；
在堆内存中保存了对象的属性。
方法不能被保存
方法是在cpu中运行计算，然后将所得到的的结果存入内存。
栈：先进后出、后进先出。
栈中保存基本数据类型的局部变量和对象调用引用值。
堆：堆可以保存那些对空间要求较大的变量。
new空间分配存储符
构造函数
作用：
创建对象，初始化对象
特点：
a.方法名必须与类同名
b.无返回值(只进不出；与普通方法区分)
c.普通方法可以与构造函数同名，但必须要有返回值
d.构造函数不能被直接调用，在new时会自动调用
e.如果不创建构造函数，编译器会提供一个默认不带参数的构造函数。写了构造函数就不提供默认的了
f.构造函数可以带参数。
g.一个类可以定义多个构造函数。
h.构造函数可以相互调用，必须在第一行。this(属性名)
java具有垃圾回收机制，不必专门去写方法处理
包
常用的包
java.lang
java.io
同一包中的类可以直接访问并使用
访问不同包中的类
import
import可以多次使用
*通配符 导入全部
封装
面向对象三大特征之一——封装
封装无处不在
封装就是将不想或不该告诉他人的东西隐藏起来，将可以告诉他人的内容公开( 隐藏对象的属性和方法的细节，只公开对外接口 )
封装的好处：
a.隐藏实现的细节
b.方便修改的实现
c.只能通过规定方法访问
权限
访问修饰符：
private 私有的 ，不对外公开 最小权限
default 默认的 不使用访问修饰符时
public 公共的 所以的类都能访问
protected 受保护的
静态 static
static在初次加载时被实例化，至始至终只有一个对象
a.属性
类的属性
适用范围：静态方法和非静态方法都可以调用
访问修饰符 static 数据类型 变量名=值；public static String context=“hello”
b.方法
类的方法
适用范围：静态方法和非静态方法都可以调用
在静态方法中，只能调用静态属性和静态方法
访问修饰符 static 返回值类型 方法名(参数列表){ 方法体 }public static void fun(){
syso
}
c.代码块
初始化static修饰的变量static{ }
单例模式
让类只有一个实例对象
a.私有化构造函数
b.提供私有类的静态属性
c.提供静态方法返回实例对象
i.判断是否实例化过对象
取的单例对象：
类名.返回实例的静态方法
对象数组
实例化对象数组Cat[] cats = new Cat[10];
向数组内填充对象数组名[ 索引 ]=对象名；//此对象名应提前实例化
数组名[ 索引]=new 数据类型();
cats[0]=cat;
cats[1]=tom;
数据类型[] 数组名 = new 数据类型[长度]
操作数组内的对象数组名[ 索引].属性；
数组名[ 索引].方法名
继承
关系传递 ，体现类之间的层次结构
object 所有类的父类
特点：
a.单继承，一个类只能有一个父类
b.一个类可以被多个类继承
c.可以有多层继承，A被B继承，B被C继承
d.子类继承父类所有的成员变量和成员方法。(除private外)
e.子类可以继承父类的方法，并且可以重写父亲的方法
f.父类构造函数不能被继承。可以使用super调用父亲的构造函数
g.如果子类的构造方法中没有显示地调用父类构造方法，也有用this关键字，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法
super()父类对象
this()本类(当前)对像
重写：
重写父类方法
@Override
1.在子类中
2.方法名，参数列表，返回值类型相同
3.访问修饰符不能比父类更严格，即子类方法的
访问修饰符要大于等于父类的访问修饰符
抽象类
不具体的类
主要用于做父类
如动物类 蔬菜类 水果类
abstract定义抽象类public abstract class 类名{ }
抽象类不能被实例化
允许(但不要求)抽象类包含抽象成员
含有抽象方法的类称为抽象类
抽象方法必须在子类中被实现，子类是抽象类除外
抽象方法
不具体的方法
用于被子类实现，子类完成方法体访问修饰符 abstract 返回值类型 方法名(参数列表);
final
final 修饰变量 或常量
访问修饰符 final 数据类型 变量名=值；
2.方法 不能被重写的方法访问修饰符 final 返回值类型 方法名(参数列表){ }；类 不能被继承的类
访问修饰符 final class 类名{ }；
接口
接口 interface
完全抽象
接口内：静态常量 和 抽象方法
常量默认有 public static final
方法默认有 public abstract
接口是一种规范、约定
遵循抽象类所有原则
一个类可以实现多个接口
接口没有构造函数
实际对象要看new的是什么
使用父类作为引用 实例化子类对象
父类引用但只引用到子类继承父类的成员
instanceof
判读对象是否是什么类型
对象名 instanceof 类型
返回 ture 或 false
使用接口引用实例对象
能引用到的是该类实现接口的方法
接口：
设计
规范
约定
扩展
能力
接口可以作为参数，也可以作为属性，还可以被类直接调用
简单工厂模式：
1.构建父类对象
2.子类继承父类
3.创建工厂类，提供实例化对象的方法.
异常处理
try{
}catch(异常类型 e){
}
2.
try{
}catch(异常类型 e){
}catch(异常类型 e){
}catch(异常类型 e){
}catch(异常类型 e){
}
catch的顺序要先子类后父类
try{
}finally{
}
4.
try{
}catch{
}finally{
}
5.
try{
}catch{
}catch{
}
…
finally{
}
finally无论是否有异常，无论是否处理，finally都要执行 (system。exit(0)时不执行)
throw 抛出异常
throws在方法中声明异常
工具类
object是所有类的父类
equals主要比较的是内容
==比的是对象的地址
值类型与引用类型的转换
装箱和拆箱 消耗性能
int t=5；
//装箱是将值类型转换成引用类型
引用类型 =值类型
integer tt=t；
//拆箱是将引用类型转换成值类型
值类型=(值类型)引用类型
int i=(int) tt
集合
长度固定 队形连续
集合
长度可变 队形多样
set接口
无序 - 是指元素存入顺序和集合内存储的顺序不同
无重复 - 两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个
arraylist用于常查少改
linkedlist用于常改少查
文件与流
流
动
数据的流动
数据传输的过程，有开始有结束
字节 byte
1byte=8位
计算机的存储单位
字符
文字表达的内容
除文本文件外，其他文件均匀标准单位(字节)去输入输出读取
序列化
保存对象的瞬时状态
反序列化
就是把对象取出来
1个进程 可以包含一个或多个线程，其中必须要有一个主线程。
继承式适用于多个对象，每个都是独立线程
接口式适用于一个对象，多个线程同时操作
这里只是把平时上课的一些笔记转移了上来，并不够细致，还需要更多的总结与学习来源：https://www.icode9.com/content-1-435201.html
1758
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
