一个月的JAVA总结

初遇java

首次接触java是在大二上学期的时候，在学校老师讲的很快，再加上本来也没好好听讲，所以基本也没学到什么，为了应付考试和项目自己看过一些书，知道一些很少很少的用法。

一、 开始学习

1. 什么是java？
   java是一种编程语言

2. java的优势是什么？
   我觉得java的应用范围很广，基本上方方面面都能涉及到，不过目前我学习的是面向网站的javaEE。

3. JDK版本的选择和安装
   越高的版本的JDK功能是越多的，但是对于生产开发，很多应用还用的是旧版的JDK，类似于1.6,1.7，所以在学习时，使用的是JDK1.8.。

4. 环境变量的配置
   百度经验描述还是比较详细的

5. IDE的选择
   我选择的是myeclipse2019.4.0，老实说我觉得这个版本的界面比我之前上学用的2014好看太多了，所以下下来的时候还是很开心的（不过还是需要吐槽一下，myeclipse启动的太慢了…隔壁朋友的eclipse每次秒启动，我要等好久或者重来好多次）

6. 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（条件）{
}

switch

switch（n）{
case  1：
break；
default：
}

这里要说明的是，case具有贯穿性，所以在使用时，可以根据需求，来判断是否需要些break
能打破switch结构的，只有break和}。

for

for（迭代变量；循环条件；控制循环次数的操作）{
}

while

while（）{
}

while是先判断条件是否成立，再执行的

do…while

do{
}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]是取不到的，如果这样写，会提示数组越界。

foreach

for(数组元素类型  变量名 :   数组名){
         语句;
}

多维数组

多维数组我的理解就是在一维数组中，将他的元素也变为数组，就成了多维数组

多维数组的创建

数据类型 数组名 =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<numbers.length;i  ）{
       syso（“number[i]”）;
}

//foreach
for(int  i :   number){
    syso（“number[i]”）;
    }

冒泡排序

for（i = 1; i < n; 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 修饰

1. 变量 或常量

   访问修饰符 final 数据类型 变量名=值；

2.方法 不能被重写的方法

访问修饰符  final 返回值类型  方法名（参数列表）{ }；

1. 类 不能被继承的类

   访问修饰符 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./content-1-435201.html