EasyDemo*Java SE 基础实用篇(个人总结)

JavaSE基础

0>基本数据类型默认值：

基本类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘\u0000’
boolean	false

1>注释

**文档注释-〉用来生成网页格式的帮助文档

**时间&作者

2>变量

**概念->程序执行过程中，在指定范围内变化的量

**格式->数据类型 变量名 = 初始值

**变量的使用原则

！就近原则

@如果在方法中找到，使用局部变量

@如果在类中找到，使用成员变量(如果在类中没有找到，将报错)

**成员变量与局部变量的区别

!内存位置

@成员变量->堆内存 @局部变量->栈内存

！默认值

@成员变量->有 @局部变量->没有

！成员的创建与销毁时间

@成员变量->随着对象的创建/销毁而创建/销毁

@局部变量->随着局部函数的创建/销毁而创建/销毁

3>数据类型的转换-->多态(编译看左边，运行看右边)

**隐式/自动转换(小->大)

! 格式-〉Animal animal = new Cat();向上转型

**强制转换(大-〉小)

！格式->(转换后的数据类型)需要转换的数据 == Cat c = (Cat) animal;向下转型

4〉运算符

**算数运算符

! ++ -- (x++ 先用后加；++x 先加后减)

**逻辑运算符

! 与运算符&&(有假则假) ！或运算符||(有真则真)

！异或运算符^(相同则假，不同则真) ！非!(取反)

**三元运算符

! 格式-〉(条件) ? 表达式1 : 表达式2;

5>结构语句

**判断语句 if

!格式-> if () {}; if () {} else {}; if () {} else if () {} else {};

! if () else if (){} else if () {}...使用情况？

如果除了上面的情况，接下来的都可以统一处理，就可以else结束下，如果只判断上面三种状况，就不需要else

**选择结构 switch

!格式->switch (表达式) { case1:语句1;break;case2:语句2;break;...default:break;}

!支持数据类型

@支持Enum类型、String、和部分基本类型的包装类（如：Character、Byte、Short、Integer）

**循环结构-> while(至少循环一次) && for(for for)

! while 格式-〉初始化变量 while {对变量进行判断} {循环体}

! do...while 格式-> 初始化变量 do {循环体} while (对变量进行判断)

！for 格式-> for (初始化语句;条件判断语句;控制条件语句) {}

! 高级for格式-> for (数据类型 变量名[随意]: 被遍历的集合或数组)

!何时使用普通for,何时使用高级for?

 需操作索引时用普通for,其他时候用高级for(Iterator 增强for)

6>Function

**函数的格式

！修饰符 返回值类型 函数名(参数列表)->(参数类型1 形式参数1,参数类型2 形式参数2,...)

**函数的种类

！没有返回值的(void) !有返回值的(基本&&引用数据类型)

**定义函数的2个明确

!返回值的数据类型 ！是否有未知的内容参与即 参数列表

**函数传参注意问题

!java中参数传递

@基本数据类型-〉形参的改变对实参没有影响

@引用数据类型-〉形参的改变对实参有影响

**函数的重载

！概念-〉在一个类中，存在多个名字相同的方法，但是参数列表不同

7>构造函数

! 格式->修饰符　类名(参数列表)　{}

！特点

@构造函数函数名与类名相同 @没有返回值和返回值类型

@先执行父类的构造函数，在执行子类的构造函数

@如果父类中没有空参构造函数，子类中必须使用super(参数列表)去访问父类中其他的构造函数

@如果父类中没有空参构造函数，子类可以访问本类其他构造函数this(参数列表),之后再访问父类的构造函数

@super(参数列表)&&this(参数列表)都要在构造函数的第一行，那么->唯一性

8>Array(堆内存中)

**概念

！可以存放多个相同数据类型数据的容器

**二维数组

!表现形式

@int [][] num = new int [3][3] //定义了一个三行三列的二维数组

@int [][] arr = {(3,4,6),(5,67,8),(0,9)} //第一个一维数组 arr[0] = (3,4,6);

**案例

!遍历 ！最值 ！查找

9>InnerClass

**前提

！内部类必须继承或实现一个外部类或接口

**访问的特点

!内部类可以访问外部类的成员，包含私有成员

!外部类要想访问内部类的成员，必须要创建内部类对象，才可以访问

**内部类根据位置不同可以分为

！依据成员位置划分：成员内部类 ！依据局部位置划分：局部内部类

**成员内部类

！访问内部类的两种方式

@外部类.内部类 对象名 = new 外部类().new内部类()

@在外部类中定义一个访问内部类的方法，然后外部类对象，调用该方法(推荐：暂时看不太懂)

*成员内部类的修饰符

@private 提高数据的安全性　　@static 调用方便

**局部内部类

!特点

@局部内部类可以直接访问外部类的成员

@局部内部类，如果要访问外部类的局部变量，这个局部变量要加final,为了延长局部变量的生命周期

**匿名内部类

！格式-> new 父类/外部类 or 接口() {子类内容/自定义内容} -> Person p = new Person(){};

10>泛型

**上限

! ? extends Long 只能存储Long或Long子类类型数据

! ? extends Comparable(接口) -> extends后的可以是class、interface

**下限

! ? super Integer 只能存储Integer或Integer父类类型数据

**<>里面用来指定元素的数据类型，不能是基本数据类型

**通常来说，只有集合才需要泛型

**与集合有关用<E>，否则都是用<T>

11>IO

**分类 
**按数据类型分 
!字节流-> InputStream(读) -> 子类FileInputStream->fis.read();     !OutputStream(写) -> 子类FileOutputStream->fos.write()
**字符流
!Reader(读) -> 子类FileReader->fr.read()  !Writer(写) -> FileWriter->fw.write();
**转换流
!InputStreamReader/OutputStreamWriter ->字节流转换为字符流

**输出流都可以用flush(), flush主要用于把内部缓存的数据,作实际输出而且清空 [简记:os fw 都可flush]
**文件读写完成后要及时关闭输入输出流

12>Collection

**单列集合Collection

!成员-> List(ArrayList&&LinkedList) && Set(HashSet[LinkedHashSet]->hashCode&&equalsl**TreeSet->Compare to/Comparable)

!List集合特点：有序&&可重 !Set集合特点:无须&&不可重

**双列集合Map

!成员->HashMap[hashCode&&equals]&&TreeMap[Compare to/Comparable]

!特点->键值对(Key[唯一],Value[可重])

13>MultitThreading

**概念->一个程序/软件(进程)下包含N多模块(线程),这N多模块(线程)可以同时运行

**实现的两种方式

! extends Thread(overwrite run(线程自身的任务代码))->创建Thread类的子类对象->对象.start()

! implments Runnable(overwrite run(线程自身的任务代码))->创建线程->线程对象.start()

**状态

!create start runnable join stop destory

!sleep(lang.Thread)->must catch Exception->参数必须指定一个时间->可以在任何地方使用

!wait()&&notify/all(lang.Object)->不必要catch Exception

->线程挂起(不必要指定一个时间),直到超时或线程被唤醒->只能在同步控制方法或同步控制块里使用

**安全

！线程同步

@synchronized关键字->同步代码块(推荐)->格式－>synchronized(this) {}

@同步函数-> public synchronized void Hi(){}

14>关键字

**this

!概念->当前对象的引用

!格式

@this.成员变量 @this.成员方法

!使用情景

@局部变量名与成员变量名同名时->使用this区分

@构造函数内

**super

!概念->父类的引用

！使用情景->extends时子父类成员变量重名，使用super关键字

15>Interface

**表示-〉这个对象能做什么

**实例化-〉接口如果要实例化，实现该接口的子类必须复写此接口里的全部抽象方法

**函数-〉没有构造函数，只有抽象函数(方法)；函数只能声明出来，没有方法体

**变量-〉final static 变量名 == 常量(放在常量池中)

**使用情景-〉部分子类必须要完成的操作(说英语 娶媳妇...)

**用途-〉接口只能做方法声明

**关注点->关注一个事物的操作用接口

**总结-〉接口只能有抽象抽象方法和不可变常量

-〉接口主要用来抽象功能

16>Abstract Class

**表示-〉这个对象是什么

**实例化-〉抽象类如果要实例化，继承该抽象类的子类必须复写此抽象类里的全部方法

**函数-〉有

**变量-〉普通变量

**使用注意事项-〉抽象类里的抽象方法必须全部由子类复写，否则该子类只能是抽象类

**用途-〉抽象类中可以做方法声明也可以做方法实现

**关注点->关注一个事物的本质

**总结-〉抽象类可以有具体的方法和属性

-〉抽象类主要用来抽象类别

17>代码块

**执行顺序->静态代码块->构造函数->局部函数

18>修饰符

**static

!特点

@多个对象共享一个属性，使用静态

@被静态修饰的方法可以直接使用类名调用

!静态成员与普通成员的区别

@创建与销毁消失时间

@静态成员->随着类的加载而存在，随着类的消失而消失(先于对象而存在)

@普通成员->随着对象的加载而存在，随着对象的消失而消失

!调用上的区别

@静态成员-> 对象.成员 or 类名.成员 @普通成员->对象.成员

!使用位置上的区别

@静态成员-> 方法区 @普通成员-> 堆内存

!理解上的区别

@静态成员->多个对象共享一个属性 @普通成员->每一个对象单独所拥有的

**final

!用处->用于修饰类，方法，变量

!特点

@final修饰的类->不能被子类继承 @final修饰的方法->不能被子类overwrite

@final修饰的变量->值不能改变，相当于一个常量

**权限修饰符->public private protected

19>Exception

**类型

!可捕获-> try catch finally !不可捕获->throwable(throws[on function]&&throw[in code])

20>class&&object

!class概念-〉属性和行为的集合

!object概念->类的具体体现

21>封装

!概念->隐藏对象的属性和具体的实现细节，对外提供公共的访问方式

!体现->@class @package @function @private

22> ||   &&

  || && 可以如下写法:
  2>3 || 4<6 || 7>9
  2>4 && 3<5 && 8>1