java入门知识点总结
来源：互联网 发布：深圳单片机解密 编辑：程序博客网 时间：2024/05/22 04:43
程序=数据+算法
机器语言10101010
汇编语言
高级语言
1-c--面向过程
2-java c++ c#
1--javaEE:b/s
1-java---sun
1-面向对象
2-java语言
3-数据库：oracle mysql
4-web:html css js jquery
5-web高级：jsp servlet tomcat
6-企业级应用：框架
2--java：sun--1.6
1-mysql
2-oracle
3-特点：
1-面向对象：
1-love(persin1 person2){}---喜欢张三李四
2-zhangsan.love（lisi）---zhangsan xihuan lisi
2-跨平台：1-jvm 2-垃圾回收机制
1-jdk
1-下载
2-安装：不要中文路径
1-jvm：java的虚拟运行环境
2-jdk:软件，java 的编译运行环境
3-jre:软件，java的运行环境(jvm)
3-配置环境变量：告诉操作系统
1-java_home:C:\Program Files\Java\jdk1.8.0_11
-jdkan安装路径
2-classpath:.;%java_home%\lib
classpath实质是一个数组
-. : 配置用户自定义的class(.class文件)路径
1-.:当前路径
2-..：父路径
-%java_home%\lib：系统的class路径
3-path:%java_home%\bin;
-配置可执行文件的路径 .exe
-javac:编译命令（将java的源代码编译成class文件）
1-语法：javac 文件名
-java:运行命令
1-语法：java className
4-验证jvm环境
1-win+r
2-输入cmd 回车
3-javac java
5-hello world
1-编写程序
2-cmd---
1-cd命令切换到程序所在的位置
2-javac 文件名
3-java hello
--------------------------------------------------------
一处编译处处运行
安全性 .jsp .action .do
1--电脑习惯
1-显示后缀名
2-文件显示模式：详细信息
2--文件夹：
3--iteye csdn
4--java运行流程：
1-java源文件(xxx.java)---javac->xxx.class（字节码）
-java->结果
2-cmd：
5--注释： 程序员使用
1-//:单行注释
2-/* xxxx */：多行注释
3-/** xxxxx */:文档注释（会被解析）
6--关键字：在一种语言中，已经被赋予特定含义的单词
1-小写 void int int = 1；
2-不能再次使用
7--标识符：在程序中需要程序员自己定义名字的地方
1-函数名，变量名，类名，包名
2-首字母不能为数字(规定)
3-字母，数字，_，$
4-驼峰标识(规范)：每一个单词的首字母大写 StudentName
8-标点：
1-空格：分隔符 int num=1;
2-;:结束符
3-{}：代码体 for if main hello{}
9--变量：
1-概念：可变化的数值
2-本质：内存空间
3-三要素： 类型 名字=值
10--数据类型：
1-基本类型：java固有的类型
1-boolean char byte short int long float double
2-特殊格式：long float
3-float比long能够容纳下更大的整数
byte 1字节
short 2字节
int 4字节
long 8字节
单精度float 4字节
双精度double 8字节
4--在java中：boolean类型数据只允许取值true和false，不可以非0或0的整数替代true和false。
5---byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
6--当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。1+"abc" 1abc
7--boolean类型不可以转换为其它的数据类型。
注意：强制类型转换有可能损失精度。
2-复合类型(引用类型)：多个基本类型或者复合类型组成的类型
3-数据类型转换：
1-自动转换：字节数小--〉大 int num = 1; long l = num;
2-强制转换：字节数大--〉小 long l = 1; int num = (int)l;
4-字符在计算机里是以asc码形式存储
11--进制：
1-二<--->十进制：
12--运算符：
1-++:
1-前加： ++num 先加在运算
2-后加： num++ 先运算再加
2-?:
1-是一个算数运算，会返回一个确切的结果 int num = n>2?0:1;
2-:前后的两个值的类型必须相同
A &&B a是假，则不运行B；
A&B 无论a是假，都运行B；
--------------------------------------------------------
jquery $()
var num = 1；
var str = “aa”;
‘a’
源代码-->javac-->字节码（可执行文件）
--->java--->结果
jvm jdk jre
环境变量配置：
1-java_home :jdk安装路径c:\java\jdk
2-classpath:.;%java_home%\lib
3-path:命令文件路径bin
1--java
1-关键字：class
2-标识符：自己起名字的地方
1-首字母不能为数字 字母 数字 _ $
2-int num = 123_456;//jdk1.7(必须在1.7以后,两个数字之间)
3-变量
1-空间
2--三要素： 类型 名字=值
1-类型：决定空间类型（int占4个字节）
3-java是一种强数据集类型的语言
4-数据类型
1-基本类型：8
1-顺序
2-字节数
3-各个基本类型之间的相互转换
1-自动转换byte--int--long--float（占4个字节） char--int
2 8最快的速度二进制位移
2-强制转换char i = (char)97；
“123”--（int）“123”不能
2-复合类型(引用类型)：由若干个个基本类型或者复合类型组成的类型
1-class interface String char
5-运算符
1-？：(三目运算符) double num = 1>2?9:9.0f(float不能省略后缀) long 1 =9
6-流程控制语句：
1-分支语句：互斥
1-if：
1-单分支if（boolean）{....}
2-双分支if（boolean）{....}else{....}
3-多分支if（boolean）{....}else{....} if（）{}else{}（若干个）
1-问题:条件覆盖问题（上面的条件不要覆盖下面的条件）
2-if(){..} if(){} if(){}
2-switch（算数表达式）：
1-语法：
1-语法：switch（表达式）{
case常量1：
xxxx
break;
case常量2：
xxxx
break;
case常量3：
xxxx
break;
}
2-常量：值不可变的变量
1-int num = 1； num =2；
2-常量必须赋初值
3-switch 表达式：
允许byte short int char 枚举 jdk1.6
String jdk1.7
4-case --- if
- default -- 最后的else：用来收尾：
如果前面的case一个都不走，
就走它（可以省略）
-break：用来终止当前case的执行
5-case 的优先级要高于default
6-if/switch:
1-if:适合范围处理（<>）
2-switch：适合固定值（==）
2-循环语句：
--------------------------------------------------------
int num = 1;//声明(开辟内存空间) 初始值
num = 2;//赋值：空间已经存在
1--循环：
1-for：
1-语法:for(b1;b2;b3){.4.}
2-b1:初始化 int num = 1;
3-b2:条件判断语句 num<=9;如果b2返回true则循环会继续
4-b3：步长 num=num+1
5-执行顺序：1 2 4 3 2 4 3 2
6-次数n：b1=1 b2=n+1 b3=n 4=n
7-三个表达式都是可选，分号不能省 for(;;){}
8-单循环：线性 ；双循环：面 ； 三个循环：立体
9-增强for循环(foreach)
1-语法；for(char i : 数组){}
2-while：
1-语法:while(bool条件){.....}
2-for:适合有次数限制 while：没有次数控制
3-do-while：
1-语法：do{...}while(bool条件);
2-无论如何都会运行一次
4-没有goto：关键字；保留关键字)
5-关键字：
1-break:终止
1-switch：用于终止一个case的执行
2-循环中：终止循环的运行
2-continue:继续
1-循环中：终止本次循环，继续下一次循环
3-结论：
1-影响的是直接包含循环：就近原则
2--数组：
1-概念：一组数据的集合，类型相同 1 2 3 5 8 0
2-特征：
1-类型相同
2-长度不可变
3-地址连续
3-语法：
4-复合类型：
1-new
5-下标：0开始
6-length:数组的一个属性，记录该数组中数值的个数
1-属性：变量，类中，但是方法外的变量
2-变量的作用域：{}
--------------------------------------------------------
1--数组：
1-定义：长度 new
2-赋值，获取：下标：0
3-长度：数组名.length
4-遍历：for
5-操作：
1-排序
2-选择排序：java实现
6-维度：
1-一维数组：一组类型相同的数据的线性集合(线)
2-二维数组：数组的数组(面)
--------------------------------------------------------
1--五子棋：
1-进行每一个方向判断输赢前，计数器重置为1
2--面向对象：：将现实抽象成一种虚拟的过程
1-概念：关注的是动作(行为)的发出者
2-面向过程：关注点：事情怎么做，而不关心谁来做
love(person p1,person p2){
......
}
3-步骤：
1-表白的对象----〉模板(概念，描述)
2-对象去做事情
4-概念：
1-OOA：做事情--做事的对象---对象的模板
2-OOD：模板(大小，打电话，发短信等)---对应的对象---做事情
3-OOP：面向对象的编程
5-面向对象中的两个基本概念：
1-类：模板 对一类事物所具有的共同特征和行为的一种描述,对现实中一类事物的一个抽象
1-特征：变量----属性:全局变量(成员变量)
1-属性可以被权限修饰符修饰
2-变量的分类：
1-作用域：全局 局部
1-全局：可以被当前类的所有方法访问的变量
1-全局变量包含属性
2-局部：方法中的变量，只能被当前方法(或者for if)是用
1-局部变量不能重名
2-局部跟全局可以重名
2-类型：基本 复合
2-行为：方法
1-*1-public:权限修饰符：public protected 默认 private
* 1-作用范围
*2-void：返回值
* 1-事情完成后需要交付的结果
*3-call：方法名
*4-String name:参数
* 1-要想完成一个事情，所需要的外界条件
*5-{}：方法体
* 1-过程
2-方法外面(类里面)不能直接写逻辑代码
3-如果一个方法需要返回值，则该方法中一定要有一个return语句
2-对象：个体 实实在在存在的一个具体的实例
1-创建：Phone p1 = new Phone();//int num = 1;复合数据类型
2-对象的使用:
1-调用方法：对象名.方法名(参数)
2-访问属性:对象名.属性名
3-匿名对象:声明时不给对象起名字，直接使用
1-安全
2-耗资源
4-类是对象的描述(抽象),对象是类的实例(具体体现)
5-定义类时：为了保证属性值的有效性
-将属性设置为private(不可见)
-对外提供一个public的setXXX的方法
-该方法的作用：负责给该属性赋值
-对外提供一个public的getXXX方法
-作用：负责获取对象的该属性的值
3-面向对象编程：
1-定义类(属性，方法)
2-声明对象
3-调用方法
4-三个特征：
1-封装：面向对象的抽象的过程(类的形成过程，方法的形成)
1-好处：
1-代码的重复利用
2-隐藏细节
2-this：当前对象：当前哪个对象正在调用该方法，则方法中的this就指的是的哪个对象
1-.:当前路径 通配符
2-在一个类的方法中可以通过this关键字访问本类的属性或者其他方法
3-可以省略
1-当方法中有重名的变量时，则不能省略this
3-构造方法：public Person(String name){}
1-方法名：类名相同
2-没有返回值，不等价于void
3-作用：用于创建类的对象
4-调用方式：普通方法：.调用 构造：new
5-如果类中没有明确定义构造方法，则jvm会自动分配一个空构造
6-代码：this.属性=值 ： 初始化对象的每一个属性值
4-重载overload：在一个类中，方法名相同，参数不同的
1-参数：
1-数量
2-类型
3-顺序
2-返回值不同不能作为重载的判断依据
3-含义：同一种行为的不同表现方式
5-传参：
1-值传递：
1-基本数据类型
2-是将元数据的值复制了一份给了参数变量
3-返回值方式
4-String：字符串：复合类型
2-引用传递：
1-复合类型
2-本质：没有引用传值；只不过复合类型的值是地址
6-包：文件夹
1-作用：对一个工程中的类文件进行分类管理
2-.:层次结构com.test1
3-命名：全小写；域名倒写 com.baidu.test1 com.baidu.test2
4-类文件的第一行代码：package com.java1 包的声明
5-导包：import com.java1.test;
1-当需要用到另外包里的类时
7-封装类：
1-自定义：Person
2-系统封装类:String System
1-import java.util.Scanner;
2-java:基础包 javax：扩展包
1-io：输入输出流包
2-lang：默认包 不需要导入
3-net：网络
4-sql:数据库
5-text：文本操作
6-util：工具
8-注释：
1-//
2-/* */
3-/** */：文档注释
2-继承：
3-多态：
--------------------------------------------------------
1--面向对象：
1-封装：
1-实现代码的重复利用 int num = 2;
2-隐藏细节
3-类：概念---〉通过一类对象抽象出来
-对象：根据类生成的一个具体的实例
-方法：public void add(int num1,int num2){...}
4-重载：一个类中，方法名相同，参数不同 int num =p1.add("a",12);
5-构造方法：
1-方法名
2-返回值：跟void是两回事，返回值就是本类的对象
3-this.xx = xx;
4-空构造
2-继承：类跟类之间的一种传递关系
1-父类更通用，子类更具体
2-关键字：extends
3-技术角度：多个类中具有一些共同的全局变量和方法，
-将这些变量和方法继续提取出来，封装成一个类，让这多个类继承该类
4-单继承，一个类如果没有显示继承另一个类，则默认继承Ojbect
-继承可以传递 stu is a Person
5-父类本身也是子类的类型(身份)
6-父类的引用指向子类对象
7-abstract:
1-修饰类：抽象类
1-不能直接实例化对象，必须被继承
2-技术角度：如果想让一个类不能被实例化，则定义成抽象类
2-修饰方法：抽象方法
1-只能出现在抽象类中
2-必须被子类重写overread
8-重写： 子父类中相同行为的不同的表现方式
1-子父类
2-子父类之间，方法的声明相同，方法的实现不同
9-父类不能调用子类扩展的方法或属性(一个对象能调用什么方法，取决于栈里的引用的类型)
10-接口：Stu like a person
1-多实现(继承):implements
2-定义：interface
3-完全抽象化的类
1-只能有抽象方法:默认修饰符：public abstract
2-成员变量：静态常量 public static final
4-为了解决单继承
5-标准
11-关键字：super:当前类正在运行的对象的父对象
1-this：当前类正在运行的对象
2-用法：
1-this(...) super(...):调用构造方法
2-this.methodName()/this.attributeName:调用普通方法或属性
3-结论：
1-类的构造方法里的第一行代码：super();
-调用父类的空构造，先初始化父类对象
2-如果父类中没有的空构造，则必须显示的在第一行代码中写出调用父类的哪个构造
12-子类不能继承父类中似有的成员变量或方法
13-成员变量/局部变量：
1-成员可以不赋初值，局部必须有初值
2-初值：0 0.0 null 空格 false
3-成员变量在编译时就载入内存
14-结论：
1-如果父类没有空构造，则子类的空构造也不回默认分配，必须显示的声明出来
2-规范：定义一个类时，尽量显示的将空构造声明出来
1-子类的构造中不用显示的调用super(...)
2-子类会重用空构造
3-多态：一个对象的多种表现形态
1-父类的引用指向子类对象
2-使用：当在一个类中需要定义若干个相同功能的方法，这些方法的参数类型是兄弟关系，
-这时就可以将这几个方法合并成一个方法，参数需要改成父类的引用
3-表现方式：重写，重载
4-instanceof:验证一个对象的类型
1-验证对象在堆里的类型(new)
5-强制类型转换：person p = new Stu(); Stu s = (Stu)p;
1-前提：该对象在堆里new的就是该子类(instanceof 为true)
2-子类--〉父类：自动
3-父类--〉子类：强制
6-封装类：
1-自动装箱解箱(jdk1.5新特征):基本类型《--》封装类
4-Object:超类
1-构造：空构造
2-toString():返回一个对象的字符串表示形式
3-equals:
1-==:比较两个对象栈里的值是否相等
2-equals:比较两个对象的内容是否相等(堆里的内容)
--------------------------------------------------------
1--面向对象：现实---虚拟
1-编程：行为(方法)---->对象----〉类
1-ooa ood oop
2-类 对象
3-特征：
1-封装：类 方法 属性(变量) 包
1-形成一个集合体的过程
2-继承：
1-抽象类----〉接口 抽象方法：理想
2-类---〉接口 接口---〉接口
3-继承：不用做出改变
-实现：实现抽象方法
3-多态：父类的引用指向子类对象
1-instanceof
2-重写 重载
4-接口：
1-属性(全局)：public static final
2-方法：public abstract
3-static:
4-final:常量 public final int num = 1;
1-常量在定义是必须赋初值:在对象初始化前赋值
1-在全局声明时给值：在编译时值进入内存
2-在构造里给值：运行时动态给特定对象赋值
2-在内存空间产生时，常量有值即可
3-还可以修饰类 方法:
1-修饰类：最终类：不能被继承
2-修饰方法：最终方法：不能被重写
5-static：静态
1-修饰：属性，方法，类
2-修饰属性：静态变量 类变量
1-static一般情况下会跟final搭配使用
2-属于类，不属于某一个对象，普通属性属于某一个对象
3-可以直接由类名访问
4-静态变量在内存中只产生一块内存空间
5-在编译时就已经载入内存，对象属性在new时(运行时)才载入内存
6-局部变量不能被static修饰
3-修饰方法：静态方法
1-可以直接由类名访问
2-Math
3-静态方法中不能直接访问非静态的方法或属性
-不能使用this super关键字
4-修饰类： 静态类
1-只能修饰内部类
1-内部类：类中的类
5-静态代码块：
1-语法：static{
System.out.println("aaa");
}
2-运行时机：编译时
3-作用：执行一个类中耗资源的代码,资源申请
6-构造不能被static final abstract
7-static应用：
1-单例模式：一个类在内存中只有一个实例
1-私有的构造
2-私有的对象
3-共有的静态方法---〉返回值--〉私有的对象
4-分类：
1-懒汉式：饱汉式:当第一次调用静态方法时才初始化
2-饿汉式：定义时直接初始化
6-内部类：
1-概念：类中的类
2-优点：安全，只给外部类这一个类服务
3-字节码：外部类$内部类.class
4-匿名内部类:
1-为了保证给一个方法传递的参数是唯一一个对象
2-new的时候，new的是他的父类或者父接口
7-链表：线性结构
--------------------------------------------------------
1--集合：
1-自定义数组：3 add()
2- 链表：head
2--集合：数组
1-线性集合:Collection
1-List:有序可重复的线性集合
1-ArrayList：数组形式
2-linkedList：链表
3-操作：
1-定义
2-添加：add() addFirst()
3-获取元素：get(index)
4-长度：size()
5-遍历：for 增强遍历foreach
2-Set:无序不可重复的线性集合
1-HashSet：hash算法
1-hash码 hashCode():获取一个对象的hash码的数值格式
2-如果需要存储自定义类型，则需要该类重写object的hashCode()方法
-和equals方法
3-规范：一个封装类需要重写object里的toString,equals,hashCode方法
4-比较相等：
1-==：比较基本类型，栈里的值是否相等
1-所以如果比较复合类型，则比较的是地址
2-equals：比较对象的内容是否相等，比较复合类型
2-TreeSet：树
1-自然顺序：compareTo：比较两个对象是否相等
2-问题：
1-不能存放不同的数据类型
2-不能存放空值null
3-compareTo:用来比较两个对象的大小顺序：来自Comparable接口
1-如果想让一个类型的两个对象进行大小比较，实现Comparable，重写compareTo
3-set的不可重复性：
1-后来的如果跟之前的相同，则不进行add操作
2-键值对集合：Map
1-HashMap
1-问题：
1-可不可以放null？
1-如果可以：value key
2-结论：都可以为null
2-key value：能不能重复
1-如果可以：哪个可以重复
2-结论：key不能重复，如果重复，则为修改动作
2-TreeMap
1-key不能为null
3-遍历：借助keySet
3-iterator：迭代器
1-作用：对集合类进行遍历
2-好处：不依赖下表访问集合
3-方法：
1-hasNext：判断有没有下一个
2-next：返回下一个
4-问题：如何获取一个接口的对象：
1-通过new实现类
2-如果一个接口没有实现类，通过另外一个类中的一个方法(返回值是该接口的对象)
4-集合好处：
1-变长
2-可以存放任意数据类型
5-泛型：
1-数据类型
2-可以表示任意数据类型
3-作用：限制集合中所能存放的数据类型
4-使用：需要替代成某一种数据类型
5-表示：E T K V
6-不能表示基本类型，只能表示复合类型(泛型的原型是：Object)
6-算法类：
1-Arrays
2-collections:
1-myarray---><>
2-借助LinkedList：栈
--------------------------------------------------------
1--异常：
1-bug：
1-错误error：一定会发生的一种问题，不能通过技术手段处理掉
2-异常exception：不一定会出现的一种问题，可以通过技术处理
1-编译时：在编译阶段就能发生的一种异常
2-运行时：在运行的时候出现的异常
3-体系：throwable---〉exception(编译时)---〉runtimeexception
4-解决：
1-处理异常：try--catch---finally
1-语法:try{
....可能出异常的代码
}catch(异常对象){
处理代码
}finally{//可选的
一定需要运行的代码
}
2-总结：
1-finally可以省略
2-catch里面的异常对象的类型要跟try中会发生的异常匹配
3-如果catch中的对象没有匹配上，则相当于没有写try--catch
4-多个catch时，先catch子类，后catch父类
5-会在最后写一个catch：catch(Exception e)
6-finally：资源释放类代码:close()
2-声明异常：throws
1-printStackTrace():打印异常栈里的信息
1-名字
2-异常信息
3-哪一行出的该异常
5-人工抛出异常：throw
1-jdk内置了一些计算机默认的异常
2-自定义异常：
1-定义一个异常类：
1-如果是一个运行时异常：继承RuntimeException
2-如果是一个编译时异常：继承Exception
2-重写一个构造方法
3-使用：
if(异常条件){ throw new MyException("message");}
4-通常搭配throws使用
6-目的：
1-给用户人性化的提示方式
2-为了保证程序能正常运行
2--工具类：
1-字符串：
1-String
1-不可变字符串 String str = "abc";
2-valueOf():将任意类型的数据转成String
3-可以将string--〉任意类型
1-int---Integer
-double---Double
-char---Character
2-jdk1.5:新特性 ：自动装箱解箱
3-paseInt(String) paseDouble(String)
4-当字符串不需要频繁改变值，频繁读写时（读写效率高）
2-StringBuffer
1-可变
2-字符数组
3-线程安全：效率低
4-当字符串频繁改变值时(节省资源，改变的效率高)
3-StringBuilder
1-可变
2-线程不安全
2-Math：
1-random()---- 0--1
3-Random类:伪随机类
1-种子：种子一样则随机序列一样
--------------------------------------------------------
1--工具类：
1-BigInteger
2-BigDecimal:精确工程运算类
1-转换：double--->BigDecimal
1-构造：传参格式是string，如果传递double相当于还是进行的了double的运算
2-valueOf：会进行double值的处理
2-javadoc命令
3-日期操作：
1-Date：
2-时间元年间：
3-DateFormat:日期格式化类
1-抽象类
2-子类：SimpleDateFormat
4-Calendar:日期操作类
0-日历字段：
1-一年中的月份
2-一月中的天数
3-星期中的天数
4-年中的天数
1-set:给指定的日历字段，设置指定的值
2-get:获取日历中指定的数据
3-add:改变日历中的数据，在当前日历基础上加或者减多少
5-正则表达式：
1-解决问题：验证一个字符串的格式
2-本质：字符串
3-格式：
1-字母：a-z
2-数字：0-9 \d \\d
3-符号：
1-[]：匹配一个字符 [a-c]
2- -：到
3-{}：匹配次数 [abc]{1，4} X{1,} X{2}
4-*:次数 相当于{0,}
-?:次数 相当于{0,1}
-+:次数 相当于{1,}
5-():完全匹配 (abc)
6-|:或 (abc|def)
7-.:匹配一个字符，任意字符
8-\:转义 \.
1-除了键盘上的特殊符号不需要转义，其他都需要转
9-^:
1-^[abc]:开头
2-[^abc]:非法
10-$:结尾 X$
4-验证方式：matches
6-Object:超类
1-equals() hashcode()
2-toString():返回一个对象的字符串格式
1-默认：xxxx@13123
2-重写
3-clone():实现对象的复制
1-步骤：
1-重写
2-实现Cloneable
1-标识接口：接口中没有任何属性和方法
2-作用：起到一个标志作用
2-满足特征：
1-this != this.clone()---true
2- x.getClass() == x.clone().getClass() --- true
3-x.clone().equals(x) --- true
4-getClass():获取一个对象的类
5-finalize():垃圾回收机制
1-jvm会自动调用
2-final finally finalize
try{
xxxxx;
return 1;
}catch(){
return 2;
}finally{
return 3;
}
1-gc():触发垃圾回收器工作的方法
1-调用该方法只能说是给垃圾回收器发出了一个指令，但是不代表垃圾回收器就会立刻运行
--------------------------------------------------------
1--Scanner
2--IO流：
1-I：Input 数据进入内存
2-O：Output:数据出内存
3-流：字节
4-参照物：内存
5-文件：File
1-java.io
2-获取文件属性
3-修改该文件属性
6-流：
1-外部存储设备(文件，键盘，磁盘)----->内存：输入
2-内存--------〉外部存储设备：输出
3-分类：按照字节大小分
1-字节流：以字节为单位进行读写的方式
1-基础
2-通用的
3-输入流：InputStream
1- int read(byte):方法非常特殊，两个返回值
1-1个返回值：读取的字节数
2-2个返回值：读取的字节数据
4-输出流：OutPutStream
1-FileOutputStream(f):建立一个文件的输出流
1-问题：会覆盖文件中原来的内容
2-追加模式：FileOutputStream(f,true)
5-总结：流中有一个模块指针形式的参量，每次新打开一个流时，
-参量总是指向文件的开头位置(0),在同一个流对象中，
-该参量只会随着操作往后移动，永远不能移动回去
2-字符流：以字符为单位
1-升级版
2-不通用(不能操作超文本(二进制文件))
--------------------------------------------------------
1--异常：
1-try：直接处理异常
2-throws：声明异常
3-throw：
1-自定义异常：
1-运行时
2-编译时
2--工具类：
1-String：
1-String s = "abc"; String s = new String("abc");
2-不可变
2-StringBuffer StringBuilder:
1-可变字符串：StringBuffer sb = new StringBuffer()
2-StringBuffer:线程安全 StringBuilder：线程不安全
3-Object:超类
1-clone():
1-重写该方法:因为该方法是受保护
2-实现Cloneable接口：object没有实现
1-标识接口：空接口
1-作用：标记 标记一个对象能否被复制（只要实现了该接口的类，其对象都可复制）
2-getClass:获取一个对象的运行时类
3-equals:比较两个对象的内容是否相等
1-但是：object 中默认的equals原型却是比较地址(==)
2-所以子类如果想要使用equals方法，则需要重写
4-hashCode：获取一个对象的哈希码值
1-计算机对内存中数据的管理机制
2-协定：如果两个数值相同则哈希码相同
5-finalize():垃圾回收器回收对象时调用的方法
1-System.gc():触发垃圾回收器工作的方法
6-toString():对象的字符串表示方式
1-默认打印的是class+'@'+hashcode,如果需要改变则进行重写即可
2-在输出语句中默认调用
4-BigInteger:大整形，处理java中数值型所处理不了的数值运算
-BigDecimal:精确工程运算类
-UUID:equals：
1-比较内容，内容相同不代表是同一个对象
2-Set：
1-HashSet：equals
2-TreeSet：自然顺序(compareTo)
3-协定：
1-重写equals，有必要重写hashcode
2-如果两个对象equals，则他们的compareTo返回0
1--IO流：java.io包
1-计算机处理信息，文件：信息的载体（磁盘）
2-io流：input output
3-参照物：内存：人机交互
4-File：
1-建立文件对象:4种方式
2-File类中的各个方法的使用
3-静态分隔符属性
5-文件内容的操作：IO流
1-input：输入流：从信息存储介质到内存
2-output：输出流:信息从内存到存储介质
3-stream：流：信息的传输过程(方向)
4-分类：
1-字节流：基础流(可以操作左右信息，包括二进制数据 图片 视频)
2-字符流：专门操作字符的一种流
5-字节流：
1-InputStream：字节输入流
1-FileInputStream
2-OutputStream：字节输出流
1-FileOutputStream
1-追加模式：默认是替换： FileOutputStream(File file,boolean append)：append=true
6-过滤流：对数据类型进行过滤
1-FilterInputStream/FilterOutputStream:没有进行相应的读写操作扩展
2-DataInputStream/DataOutputStream:过滤流的两个子类
1-原因：实现接口：DataInput/DataOutput
7-字符流 ：以字符为单位进行读写
1-Reader/Writer：字符流的基类
2-BufferedReader/BufferedWriter:缓冲字符流(可以直接操作字符串)
1-reader：readLine:一次读取一行数据，但是不读取换行符
2-writer：writer方法写完数据后需要刷新缓冲区(否则数据不会进入文件，除非缓冲区满 了)
-close方法会自动刷新缓冲区
3-OutputStreamWriter/InoutStreamReader:桥梁流(将字节流转换成字符流)
8-对象流：直接对对象进行读写的流
1-ObjectOutputStream/ObjectInputStream
2-对象流具有过滤流特有的方法(实现了共同的接口),额外增加了一个方法WriteObject/readObject
3-序列化(串行化)：将一个对象的状态保存起来的一种机制
1-如何：实现Serializable接口
2-反序列化：恢复对象状态的过程
3-注意点：
1-只保存属性值，不保存方法和构造
2-不能保存静态属性
3-只保存属性值和名字，不能保存修饰符
4-transient:忽略序列化(比如密码)
9-打印流：
10-随机文件访问流：产生一个唯一标示符
--------------------------------------------------------
equals：
1-比较内容，内容相同不代表是同一个对象
2-Set：
1-HashSet：equals
2-TreeSet：自然顺序(compareTo)
3-协定：
1-重写equals，有必要重写hashcode
2-如果两个对象equals，则他们的compareTo返回0
1--IO流：java.io包
1-计算机处理信息，文件：信息的载体（磁盘）
2-io流：input output
3-参照物：内存：人机交互
4-File：
1-建立文件对象:4种方式
2-File类中的各个方法的使用
3-静态分隔符属性
5-文件内容的操作：IO流
1-input：输入流：从信息存储介质到内存
2-output：输出流:信息从内存到存储介质
3-stream：流：信息的传输过程(方向)
4-分类：
1-字节流：基础流(可以操作左右信息，包括二进制数据 图片 视频)
2-字符流：专门操作字符的一种流
5-字节流：
1-InputStream：字节输入流
1-FileInputStream
2-OutputStream：字节输出流
1-FileOutputStream
1-追加模式：默认是替换： FileOutputStream(File file,boolean append)：append=true
6-过滤流：对数据类型进行过滤
1-FilterInputStream/FilterOutputStream:没有进行相应的读写操作扩展
2-DataInputStream/DataOutputStream:过滤流的两个子类
1-原因：实现接口：DataInput/DataOutput
7-字符流 ：以字符为单位进行读写
1-Reader/Writer：字符流的基类
2-BufferedReader/BufferedWriter:缓冲字符流(可以直接操作字符串)
1-reader：readLine:一次读取一行数据，但是不读取换行符
2-writer：writer方法写完数据后需要刷新缓冲区(否则数据不会进入文件，除非缓冲区满 了)
-close方法会自动刷新缓冲区
3-OutputStreamWriter/InoutStreamReader:桥梁流(将字节流转换成字符流)
8-对象流：直接对对象进行读写的流
1-ObjectOutputStream/ObjectInputStream
2-对象流具有过滤流特有的方法(实现了共同的接口),额外增加了一个方法WriteObject/readObject
3-序列化(串行化)：将一个对象的状态保存起来的一种机制
1-如何：实现Serializable接口
2-反序列化：恢复对象状态的过程
3-注意点：
1-只保存属性值，不保存方法和构造
2-不能保存静态属性
3-只保存属性值和名字，不能保存修饰符
4-transient:忽略序列化(比如密码)
9-打印流：
10-随机文件访问流：
--------------------------------------------------------
for update
1--打印流：
1-PrintStream
1-自动刷新
2-PrintWriter
2-默认关闭刷新功能，需要开启
2--随机流：RandomAccessFile
1-seek():设置指针的偏移量(从文件开头算)
3--多线程：
1-单线程：
2-概念：
1-程序：一系列代码数据文档的一个集合，对一个完整事件的描述 静态的
2-进程：程序在内存中运行时所需要的资源（空间） 静态的
3-线程：进程中的每一个运行单元 动态的
1-单：
2-多：
3-作用：提高运行效率
4-实现：
1-继承Thread类
2-实现Runnable接口
5-步骤：
1-继承或者实现父类或者父接口
2-重写线程的主运行方法run
3-通过调用start方法来运行线程
6-时间片：cpu是由若干的时间片组成
1-程序运行时，需要首先进入内存(等待)，等待一个空闲时间片来运行程序；如果在该时间片的时间范围内程序运行完了，或者时间片时间到了但是程序没有运行完
-将线程重新放回到内存中等待，所以线程在运行时，是通过start方法来通知cpu可以随意运行
7-生命周期：
1-创建(新建)状态:new
2-就绪状态:start()
3-运行状态:run()开始运行
4-死亡状态：线程结束(run方法结束)
5-阻塞(挂起)状态：在运行时，发生了IO异常
8-优先级：setPriority()
9-加锁：
1-原因：为了解决多线程引发的数据部同步
2-Synchronized
1-给方法加锁
2-过对象加锁
3-问题：
1-效率降低
2-引发死锁
4-Thread.currentThread().getName():获取当前正在运行的线程的名字
--------------------------------------------------------
程序=算法+数据
1--流总结：
1-计算机工作：输入输出
2-输入输出的是：数据(信息)
3-输出到：文件(信息载体)
4-输入输出：信息流动的方向 参照物：内存(处理信息的相应的程序)
1-入：由载体----》内存(程序)
1-input reader
2-出：由内存----》载体
1-output writer
5-File类： 对文件属性的操作
1-createNewFile()：创建文件
2-mkdir():创建目录
3-方法：
1-length()：long
2-isHidden()
3-renameTo()
4-list() listFiles()
4-静态属性：separator：与操作系统有关的路径分隔符
6-流：
1-步骤：
1-定义文件对象：File f = new File()
2-定义字节流关联文件对象 : InputStream is = new FileInputSream(f)
3-在2的字节流基础上可以进行二次封装
4-进行读写
5-关闭
2--线程回顾：
1-实现：
1-Thread类：真正的线程类
2-Runnable接口 ：线程的操作目标 new Thread(target)
2-步骤：
1-继承或者实现
2-重写run：
1-线程的主运行方法
2-不能是同步方法
3-点：
1-优先级：1---10 默认5
2-当前线程：currentThread()
3-getName():当前线程的名字 setName
4-生命周期：
1-阻塞态不能直接回到运行态，回到就绪态
5-同步(加锁)：
4-线程通信：
1-sleep(long):
1-持有锁睡觉
2-wait()/notify():
1-释放锁
2-必须用在同步里
3-join():A正在运行，B.join(),会将A挂起，等待B运行完，A才接着运行
4-yield():A.yield() A挂起
5-生产者消费者模型：
1-4个对象
2-2个线程，2个操作目标
3-生产者负责往容器(容量)里放食物，当容器满时，则生产者要暂停
4-消费者负责从容器中取食物，当容器空时，则消费者要暂停
5-当消费者取走一个食物时，需要将生产者唤醒
-当生产者生产一个食物时，需要将消费者唤醒
6-Component类 a-z食物
-T1 T2线程
**空指针异常：
1-原因：对为null的引用调用了其方法或属性
--------------------------------------------------------
1--网络编程：
1-InetAdress:主机对象
1-主机名
2-主机地址
2-IP：定义主机 192.168.1.1
1-端口号：唯一定位主机上的一个应用程序 tcp： 0---65535 udp：0---65535
80 21
ftp 21
http 80
3-socket：套接字：ip地址和端口号的组合
1-ServerSocket:服务器套接字对象
2-Socket：客户端套接字
--------------------------------------------------------
1--socket编程：
1-服务端：
1-Serversocket 指定端口号
2-等待客户端连接---》Socket
3-对客户端开启输入输出流
4-进行输入输出操作
5-关闭
2-客户端：
1-获取服务器主机地址InetAddress
2-根据主机和端口号获取服务器套接字
3-获取服务器输入输出流
4-进行输入输出操作
5-关闭
2--URl编程：
1-url uri urn
2-格式：协议://地址:端口号/资源名 http://www.baidu.com:80/1.jpg ftp web tomcat
3-步骤：
3--GUI:图形编程
1-java.awt:基础包
2-javax.swing:扩展包
3-组件：
1-容器组件
2-非容器组件
4-布局管理器
*5-事件监听：给某一个组件添加一个事件，当对该组件做出什么动作(addXXXListener)(xxx:action mouse key)时，执行该事件(方法)
1-三个要素：
1-事件源：触发动作的对象 注册按钮
2-监听行为：当对事件源做出什么行为 点击注册按钮
3-事件动作：当监听行为发生时，需要完成的动作 完成注册动作
4--反射：在运行时动态获取一个类的基本信息(属性，方法，父类，接口，包)，并进行操作的一种机制
1-缺点：
1-异常多
2-运行效率低
2-获取一个类的类对象：
1-Class.forName
2-String.class
3-p.getClass()
3-Constructor：代表类中的每一个构造对象
1-getConstructor(parameterTypes)
4-Field:代表类中的属性对象
1-getField("name"):获取公共属性
2-getDeclaredField：获取已声明属性
5-Method:代表类中的一个方法对象
1-getMethod(name,paramTypes...)
2-invoke:用于反射调用该方法对象
1-如果方法无返回值，则该方法返回null
5--动态方法传参：
1-语法：methodNasme(type... obj){}
2-调用：类似方法重载
--------------------------------------------------------
java:跨平台：
数据库：数据的仓库 完整的数据管理系统
作用：存储数据
1--jdbc:
1-计算机语言跟数据库之间进行通信的一种技术
2-步骤：
1-加载驱动
1-导入库文件(jar包)：工程(右键)--》build path-->config path-->lib选项卡--》点击(add jars)--》ok
2-加载驱动
Class.forName(driver);
2-创建连接
Connection conn = DriverManager.getConnection(url, user, password);
String sql = "delete from emp where empno=7735";
3-定义执行sql语句的对象
Statement stmt = conn.createStatement();
4-执行sql
int count = stmt.executeUpdate(sql);
5-关闭连接
stmt.close();
conn.close();
3-事务：
4-预处理机制：
5-存储过程：
6-数据源(数据库连接池)技术：
国际化：
单例模式
适配器模式
工厂模式
2--分层：
1-层与层之间的通信有顺序
--------------------------------------------------------
1--jdbc:
1-* 单例模式：
* 1-一个在内存中只有一个对象 new Object()
* 2-设计：
* 1-构造私有化
* 2-对外提供一个共有的静态方法
* 3-提供私有的静态对象(属性)
* 3-分类：
* 1-饱汉式：当第一次调用方法时才创建对象
* 2-饿汉式：在编译时就创建对象
2-Properties:属性(键值对)文件操作类
1-通过类加载器中的一个方法：getResourceAsStream获取一个文件流对象
2-调用该类中的load方法加载流中的键值对
3-调用getProperties(key)
3-ClassLoader:类加载器对象
1-一个jvm只有一个类加载器
2-作用：加载类，创建类空间对象
3-工作顺序：jvm启动时，首先bootstap加载器加载底层核心库(c c++)
-第二步加载jdk中lib目录中的ext/jar
-第三步加载应用库classpath(class：用户自定义的class和jdk/lib(dt.jar tools.jar))
4-预处理：
1-sql注入攻击：在输入的信息中加入一些sql片段，让底层原来的sql变为另外一个样子
1-问题：安全性低
2-预处理：PreparedStatement
3-好处：
1-提高安全性
2-sql的书写简单
5-事务机制：
1-oracle：
1-savepoint a;//设置事务保存点
2-commit
3-rollback to a;
-tollback;//回退所有保存点
4-只读事务：set Transaction read only;
2-jdbc:
1-默认自动提交事务
2-开启事务步骤：
1- conn.setAutoCommit(false)
2-conn.commit();
3-conn.rollback();
6-jdbc调用存储过程：in out in out
1-常用过程语法：
1-只有in参数
1-预处理sql
2-给in参数set值
3-执行
2-有in，有out(返回简单数据)
1-预处理语句
2-给in设置值
3-给out注册
4-执行
5-获取out的值
3-有in，有out(集合)：给定一个年龄，返回该年龄的所有人
4-有inout：
1-先设置带入过程的值
2-再对该参数进行注册
3-执行完后get获取该参数的值 ：注意：这三步中的序号保持一致
--------------------------------------------------------
总结：
1-反射：
1-Class获取类对象
2-构造对象
3-方法
4-属性
2-jdbc：
1-加载驱动：Class.forName("Driver")
2-Connection: DriverManager.getConnection
3-Statement(PreparedSatement,CallableStatement)
1-存储过程：
1-in：setXXX
2-out：先注册后get
3-inout：先set再注册再get
4-游标(列表)：(ResultSet)getObject()
4-处理结果：int ResultSet(next getXXX(""))
5-关闭
1--数据源技术：
1-:
2-dbcp：
1-导入jar：commons-dbcp-1.4.jar commons-pool-1.5.5.jar
2-导入配置文件:配置键值对数值
3-获取DataSource
3-c3p0：
1-注意：配置文件名字固定：c3p0-config.xml
2-优点：
1-封装更完善
2-自动回收连接功能
3-可以同时配置多组连接属性
2--国际化:让app能自动适应当前操作系统的语言环境
1-本地化：
2-步骤：
1-开发语言包
1-后缀：.properties
2-前缀：保持一致
3-xxx.prperties（默认包） 对应环境的包：xxx_zh_CN.properties
1-zh_CN jp_JP en_US fr_FR
2-Locale指定语言环境 Locale.getDefault()
3-ResourceBundle加载对应的语言包信息
4-调用ResourceBundle.getString(key)
3-语言包的加载顺序：
1-首先找对应locale的语言包文件
2-再找当前操作系统对应的
3-再找默认的
4-报错：MissingResourceException
4-日期/数字：
1-getDateInstance(style, locale)
- java入门知识点总结
- java入门知识点总结
- JAVA学习、JAVA入门：JAVA知识点精简总结
- jsp入门知识点总结
- Jsp入门知识点总结
- Angular入门知识点总结
- MYSQL入门知识点总结
- freemaker知识点入门总结
- Oracle数据库入门知识点总结
- 工作知识点总结 Java知识点总结
- JAVA知识点总结一
- java基础总结知识点
- Java知识点总结
- Java.知识点总结
- Java-Applet 知识点总结
- java知识点总结
- JAVA知识点总结
- java知识点总结
- 1. 创建 控制台 TCP 服务端程序步骤
- MySQL/Java服务端对emoji的支持
- android文件储存
- ECharts Java 动态加载数据，echartsjava
- 易变的关键字----volatile
- java入门知识点总结
- open/read/write和fopen/fread/fwrite的区别
- SSM（spring+mybatis）简单整合
- 【C/C++】STL容器
- 2017/8/12
- 同时装了Python3和Python2，怎么用pip
- Express不能全局安装问题
- 多校6 Gameia-6105 树上博弈 & 染色
- SOAP WebService接口功能自动化测试
