Java基础部分笔记(学习流程)

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java基础部分笔记(学习流程)相关的知识,希望对你有一定的参考价值。

基础部分:

变量:

Byte -128 ~ 127

Short  char的异同点:

同:都是16

异:Short -2^15--2^15-1

Char :无符号位  0 ~ 2^16-1 = 65535

Long float取值范围比long

Float 32位 :1个符号位,8个指数位,23个尾数位

Double64   1         11       52

 

字面量:数值,truefalsenull

关键字: goto保留字

 

运算符:

算术运算符:+  -  *  /  %(取模)  ++  --

比较运算符:>  <  >=  ==  !=

赋值运算符:+=  =  *= ......

位运算符:&  |  ~  !  >>  <<

逻辑运算符:&&(短路)  &  ||  |

三目运算符:?  :

 

逻辑控制语句:

顺序结构

条件分支语句:

If......else.....

Switch(int整型).....case.......(break)

JDK1.7及以后,switch后面可以加String

循环语句

For  知道固定次数     死循环for( ;  ; )

跳出循环:

loop : for(  ){

For(  ){

Break loop;//跳出外层循环

}}

While  ...                  while(true)

Do...while...  直到....

 

Java  1995年开始

.java   -->  ,class(字节码文件)  jvm运行字节码文件

IDE   开发工具

 

 

环境变量:

JAVA_HOME

PATH

Classpath

Javac编译     java运行

!! 见名知意

类名:

HellWorld 驼峰命名

方法名:

首字母小写,其他驼峰

变量名:

首字母小写,剩余驼峰

小写  _ 连接  user_id

常量:

全大写  _ 拼接

包名:

域名倒写 com.boninle,util(功能模块)

 

数组:

数组复制,扩容:

System.arraycopy(src , srcPos , dest , destPos , length);

《可以任意截取数组复制到任意位置》

src : 源数组,要复制的数组

srcPos ,:起始位置

dest :目标数组,要复制到的数组

destPos :目标数组的起始位置

Length :要复制的长度

 

Arrays.copyOforiginalnewlength

//扩容

方法内部:1、新建新长度数组

  2、把原数组内容复制到新数组前端

  3、返回新数组

Original:原数组

Newlength:新数组长度

Int [ ] arr={1,2,3,4,5,6};

arr = Arrays.copyOf(arr,arr.length+1);  //{1,2,3,4,5,6,0}

 

方法:修饰词  返回类型  方法名(参数列表){

方法体

}

方法签名:方法名 + 参数列表

代码重复性超过三行,代码功能超过三行,定义方法

修饰符不写时为friendly

N个人围成一个圈,13报数,最后剩下的是几号?

解答:

数组定义为 Boolean型,开始都赋值为true

变量:数组下标index,报数coutNum,剩余人数leftNum

 

 

 

面向对象

面向对象和面向过程:

面向对象:1、做这件事的对象; 2、这件事的结果

面向过程:专注每一步做什么

类:属性(成员变量)  。。的。。

方法(行为)

构造器(描述对象初始化过程的

This()  super()两者都只能放在构造器的第一行,所以只存在一个

语句块 { } (描述初始化的共性过程) 在构造器之前被调用  

对象:符合类的所有特征的实例个体

New 分配父类空间  默认初始值

调用父类构造器,初始化

分配子类空间  默认初始值

调用子类构造器,初始化

将引用值赋值给变量

     方法区(存放和类相关的所有)




面向对象的特点:封装、继承、多态

封装:属性私有化,提供公开getXXX(),setXXX()方法

继承:父类只有一个(单继承),所有类都继承自Object(基类)

向上造型:Father  f = new  Children()

向下造型:Child  d = Childf     instanceof

构造器

多态:一种事物,多种形态

重载:方法名相同,参数不同,与返回值类型无关(多态的一种表现形式)

重写:方法签名相同,与返回类型有关

返回类型:父类:int       子类:int

    Void           void

Farther         ChildFather

Animal  吃,睡     DogPig

 

关键字:

static  静态的:类(不绑定在对象上)

1、修饰属性:只有一个,所有对象公用

2、调用:类名。属性,类名。方法()

3、方法:内部只用静态的属性和方法

4、类:只能修饰内部类

5、语句块:类加载的时候自动调用

Final  最终的

1、属性:常量

初始化:可以在声明的同时

每个构造器中

语句块

2、方法:不能被重写

3、类:不能被继承,包装类都是final类   String  Integer

 

Static +  final

1、属性:静态常量

初始化:可以在声明同时初始化

静态语句块

类加载:先父类再子类

静态属性、方法、代码块都加载一遍

 

Abstract  抽象的

1、类:抽象的,可以有抽象方法

有构造器,但是不能new对象

2、方法:没有方法体

abstract  class  Animal{

abstract  void  XX();

}

 

Interface  接口(功能)   implements(实现接口)

1、没有构造器

2、所有的方法默认添加public  abstract

3、所有属性默认添加pubic  abstract  final

通常包含一些功能,与业务逻辑相关

 

 

 

内部类:

1、成员内部类

Outer outer=new Outer();

Inner  in = outer.new Inner();

 

2、静态内部类

Inner inB = new Outer.Inner();

 

3、局部内部类

4、匿名内部类

Interface Inner{

Public void m();

}

Inner a = new Inner(){ //匿名内部类,继承抽象类或者实现接口

Public void m(){

 

}}

 

枚举类:enum

Public enum Season{

SpringSummer

//静态常量

}

 

用法:Season.Spring

静态常量替代枚举

 

Object类:11个方法

equals

toString

hashcode

getClass   反射

clone  浅克隆(复制引用值)

A a=new A();

A b=a

深克隆(复制一个新对象)

 

finallize    (手动)垃圾回收      GC(隔段时间自动回收)

notify  notifyall  wait * 3  和线程有关

 

 

JavaBean  个体

MVC

Module 模型

View  视图  前段部分 html+CSS+JS+JSP

Controller  控制器

书写规范:

1、属性私有化

2、添加getset方法

3、无参构造器

4、其他构造器

5、toString方法  equals() hashCode()

Equals():

Public boolean equals(Object o){  //同一个对象

If(this==o){

Return true;}

If(!(o instanceof People)){    //类型不同

Return false;

}

People p=(People) o;   //类型相同,比较内容

Return p.name.equals(this.name) && p.age==this.age

&& p.sex==this.sex;

}

hashCode()://位置,16进制计算   Set     Map

//equals方法判断相等的两个对象,hashCode值也相等

Public int hashCode(){

 

}

6、可序列化接口,可比较的接口

 

酒店管理系统:(面向对象思想)

Hotel   Room      in  out  search

Room  num  Guest

Guest  

 

Main{

Whiletrue{

 

}

}

 

JAVA  SE部分

SE                EE                ME

SEC/SQQ):占用内存,每次更新需要下载新客户端,可以调取电脑的底层硬件设施(显卡)

SE01     SE02

API: 帮助文档  Doc

Javadoc命令   生成HTML类型的帮助文档

/**.......*/  文档注释

//   /*.....*/不可以生成帮助文档

API:应用程序编程接口           

EEB/S(浏览器,网页):不占用内存,不用手动更新,每次更新不需要下载客户端

MEPOS机(很小的客户端)

API:应用程序编程接口  (工具)

String   时间    包装类    集合

IO:输入输出《相对程序》(文件,数据)

线程     Socket(网络端口)

异常     泛型

JDK包:java.lang  

 Java.util        Java.io

Java.math       Java.sql

 

String字符串  

单元测试  JUnit

断点测试  Debug

打桩测试 System.out.println()

常量池特性:仅对字面量有效 

字面量编译器会自动存储在常量池

并且重复定义时会自动到常量池中获取

字面量拼接时,编译器会自动编译成整体

如果是变量拼接,不会自动编译到常量池

 length() 获取字符串长度

  字母122 < 127  byte 1个字节

  String 统一Unicode编码

所有字符都占2个字节

indexOf4个)  获取字符所在的第一次出现的位置

找不到字符、字符串,返回-1

重载方法,获取从i开始字符、字符串第一次出现的位置

lastIndexOf() 4 获取字符、字符串出现的最后一个位置

反向搜索

substring() 2截取字符串

 1、两个值  开始位置、结束位置

 2、一个值  开始位置,截取到最后

 前包含,后不包含

startsWidth() 是否是指定字符串开始

endsWidth()是否是指定字符串结尾

trim() 去掉字符串左右两边“空格”(\t  \n   \r)

 QQ用户名会用到

charAt(index) 获取下标为index对应的字符

   判断一段话是否为回文

toUpperCase 全部转换为大写

toLowerCase 全部转换为小写

  通常用来忽略大小写对比

equalsIgnoreCase  忽略大小写进行对比

valueOf() 静态方法   String.valueOf()类名调用

  n多个重载

作用:将各种类型的数据类型转换成字符串

contains()  是否包含

 

StringBuffer:(不用)效率低,线程安全

StringBuilder   可变字符串,字符串的内部管理

//追加字符

str.append(",就是为了迎娶白富美");

//替换字符

str.replace(15, 20,"拯救世界");

//删除字符串 0-10(10不包含)

str.delete(0, 10);

//插入字符串

str.insert(0, "活着");

//将字符串反转

str.reverse();

 

正则表达式  -->  字符串验证

邮箱的正则表达式:

[a-zA-Z0-9_][email protected][a-zA-Z0-9_]+(\.[a-zA-Z0-9]+){2,4}

eg[email protected]

^\[email protected]\w+(\.[a-zA-Z]+)+$

eg:[email protected]

要求:读懂,会改,3个文档,每天看几个(理解)

 

matches()是否和正则表达式匹配

split()字符串切割

replace()字符串替换,作用:屏蔽敏感词汇

 

包装类:

目的:为了能让基本数据类型进行对象的操作

符合一切皆对象的思想

8个基本数据类型:

byte       Byte

short      Short

int        Integer

long        Long

char        Charater

boolean        Boolean

float          Float

double         Double

 

int a=100;

Integer i=200;

i=a;//自动装箱--同下

i=Integer.valueOf(a);

a=i;//自动拆箱--同下

a=i.intValue();

自动装箱:    基本数据类型-->包装类型   valueOf()

超出-128--127范围,相当于new新对象

自动拆箱:    包装类型-->基本数据类型   inValue()

包装类型的默认初始值为null

八大基本数据类型的包装类只有Integer有常量池,其常量池范围:-128--127 ,字面量会存放在常量池中,在常量池范围内,字面量的运算原理同String

如:Integer i1=33+22;  Integer i2=55

I1==i2 --> true

Integer i1=127+1;  Integer i2=128

I1==i2 --> false

只要是new出来的对象,不管多大,都不在常量池里面

int类型的最大值和最小值:

Integer.MAX_VALUE()        Integer.MIN_VALUE()

int a=Integer.paseInt(str);将字符串转化为整型

double d=Double.paseDouble(str);

 

 

StringUtils  全部是静态方法(工具类)

作业1

阅读Apache Commons-lang.jarStringUtils文档

掌握leftPadrightPadrepeatabbreviatejoin等方法

工具类:

StringUtils     Collections     Arrays 

 

二进制:

莱布尼茨

一个地址存放一个字节的数据(8个二进制位)

从多字节到少字节,直接截取;

从少的字节扩充多字节,10011000扩充到4个字节时,补符号位

 

 

 

==============================================================

 

类先加载:

静态的属性

静态的语句块    (谁在前,谁先加载)

静态的方法   

类什么时候加载:被使用的时候

1、使用静态属性或静态方法的时候

2、New 对象时

3、使用子类静态成员的时候,父类会被加载

4、new子类对象时,父类会被加载

5、反射   xx.class

 Class.forName(java.lang.String);

注意:类只加载一次

  

 

==============================================================

Date:

long做时间维护

1970-1-1以后的毫秒差

getTime() 毫秒差值

setTime ()  设置时间

new Date() 获取当前系统时间

getYear 此类方法均已过时,不建议使用

 

Calendar: 日历类,抽象类

Calendar 抽象类   对时间进行维护

格里高利日历

getIntance() 静态方法  默认为当前系统时间

getTime() 对应的date

setTime()

获取时间分量:xx.get(Calendar.XXX);

Calendar.YEAR 年

Calendar.MONTH 月份,从0开始

Calendar.DATE  月份中的第几天

Calendar.DAY_OF_MONTH   同DATE

Calendar.DAY_OF_WEEK 一周中第几天 (周日为1)

Calendar.DAY_OF_Year  一年中的第几天

 

时间格式化:SimpleDateFormat

 

 

数组

Int[] a=new int[];

扩容:Arrays.copyOf()

 

集合:Collection(接口):存储Object类型

add(),size(),isEmpty(),clear(),remove(),Contains()

toArray()  addAll(),removeAll(),containsAll()

存储对象的引用

遍历:迭代器

用法: Iterator it=c.iterator();

while(it.hasNext()){

Object o=it.next();

if(o.equals("$")){

it.remove();

}

}

方法:hasNext   next  remove    

Foreach

集合转化成数组:toArray(Object[] )重载

泛型:编译时语法   强制类型转换(向下造型)也是编译时语法

 

List(I) :有序集合,添加顺序就是读取顺序

允许重复的

 

1、LinkedList 链表实现,修改效率高(元素增删)

节点

ArrayList 访问效率高

LinkedList  增删效率高

LinkedList 双向链表,不能做到随机访问

getFirst     getLast

LinkedList list =new LinkedList();

List.getFirst();

Vector

截取集合  subList  公用同一个空间

数组 -->  集合   Arrays.asList(args[])

转化后的集合,不支持增加、删除操作

 

实现类   2、ArrayList:数组实现,查询效率高

new ArrayList();

//根据已知集合构造新的集合,将已知的集合全部元素逐个复制到新的集合中

new ArrayList(collection);

重写了toString方法 ,[元素1.toString(),

元素2.toString(),...]

 

 

 

Set(I) :无序的,不可重复,不常用

位置由它的hashCode经过一系列运算来决定     空间大小

hashCode % 10  -->  8进制

Equals为true的两个元素  hashCode也要相等,反之,也要尽量满足

没有get,没有set,不能用普通for循环

重点:添加、删除过程

HashSet:无序的

SortedSet:有序的

TreeSet

 

Queue:队列

offer      poll       peek

Deque:双端队列

offer(First/Last)   poll(First/Last)    peek(First/Last)

只有一个端口进出 --->  栈

push    pop

 

 

Arrays.sort()

Collections    类   集合工具类

sort -->  只对List有效

1、List中的元素要实现Comparable接口(comparaTo)

2、可使用自定义比较器排序,实现Comparator接口(comparae)

Set排序使用TreeSet

 

 

 

Map(I)  映射   Key键     Value 值

键值对

HashMap:LinkedHashMap 效率高,线程不安全     

HashTable:效率低,线程安全

SortedMap:TreeMap

HashMap:(可以用来统计一个字符串,每个字母出现的次数

添加、修改put(key,value) --> value

删除  remove(key)  -->  value

查询  get(key)   --> value

LinkedHashMap :有序 - 怎么放进去,怎么取出来

初始容量:16

加载因子:0.75

容量达到 16*0.75   自动扩容一倍

哈希码

映射关系  Map.Entry

扩容后,重新计算所有元素的哈希码

HashMap

容量利用率高,查找效率会降低

提升查找效率,容量利用率会降低

LinkedHashMap  有序

不会受到容量影响

TreeMap  排序

插入会compareTo比较

时刻通过compareTo方法保持位置

效率最低

 

 

迭代:  3种

map.keySet() map中的key部分单独取出,转换成一个set集合

map.values() 获取value值的集合

map.entrySet() map中的Entry对象转换成set集合

 

 

Java.io.

Input输入流         Output输出流

文件读(Input)、写(Output)

File

创建文件  没文件创建返回true,有文件创建返回false

System.out.println(file.createNewFile());

删除文件 有文件,删除返回true,没文件删除返回false

file.delete(); ---> 文件和空目录

file.mkdics();---> 创建目录

listFiles -->列出目录下面的所有目录、文件 包含隐藏文件

listFiles(fileFilter) 过滤器

 

RandomAccessFile  基于指针对文件的操作,不属于IO

用于文件复制

指针:指针后移操作不可逆,但是可以通过seek对指针进行移动

getFilePointer

Seek

skipBytes

对源文件进行加密时,写入前要将指针先前移

Write(byte[])

Read(byte[])

文件复制过程。。。。。

文件加密:

需求:原数  计算  密码  -->  新值

新值  计算  密码  -->  原数      (异或)

 

IO流:InputStream输入流        OutputStream输出流

文件读(read)         写(write)

1、字节流:FileOutputStream  文件输出流

  FileInputStream   文件输入流

缓冲字节流:BufferedOutputStream

BufferedInputStream

2、对象流:

ObjectOutputStream

ObjectInputStream

· java.io.NotSerializableException: 你读写的对象类没有序列化

 


回顾:
File:获得属性
File file=new File(“a.txt”);
getName
length
isDirection
is-file
Exists
File[] listFiles// 目录和文件

目录 mkdir
文件 createNewFile
delete ->文件或者空目录


递归删除
重载File[] listFiles(FileFilter)
FileFilter:boolean accept()
true : 接受
false:过滤掉

RandomAccessFile
seek  移动指针
正常指针不断向后移动(读写),不可逆
getFilePointer 获得当前指针的位置

write(int)  单字节,只写入低8位
writeInt(int) 4个字节 writeFloat 
writeDouble(double) 8个字节 writeLong
writeShort writeChar 2个字节
write(byte[]) 写入字节数组(写入中文,或者一段话)

 int read() 读单字节
int 就是读取出来的单字节,填入int的低8位
int  如果返回-1,代表文件结束
int readInt() 读4个字节,
int 就是读取出来的4个字节


最后只剩3个字节,调用readInt
抛出EOFEException,文件意外结束

int read(byte[])读取多个字节,并且存入byte[]
int 表示读取出来的数据长度
int 如果为-1,代表文件结束
byte[]  就是读取出来的长度,有效数据,0-int个
例:
文件字节数:128+56
byte[] 读2次
第一次,byte数组文字存入128个字节
第二次,byte数组原始状态是上一次读取的数据,覆盖了签名的56个字节数,
剩余字节数依然存在byte数组里

 

课堂案例: 文件复制 --> 源文件覆盖(加密),另写一个新文件

字节流:FileOutputStream     FileInputStream

 

缓冲字节流:BufferedInputStream    BufferedOutputStream

缓冲区:可以实现一次性读取、写入多个字节

FileInputStream fis=new FileInputStream(file/filePath);

BufferedInputStream  bis=new BufferedInputStream(fis);

 

 

对象流:  ObjectInputStream     ObjectOutputStream     

readObject      writeObject

Serializable 接口   可序列化的

serialVersionUID 静态常量 --> 版本号

transient 关键字  标示的属性在序列化时不会把值写入文件

克隆:深克隆:克隆的是对象+引用

源对象和现对象会相互独立

         浅克隆:clone  克隆的是引用

源对象和现对象会互相影响

 

字节、对象、字符

 

字符流:

OutputStreamWriter   字符集

write写入:字符、字符数组(或一部分)、字符串(或一部分)

InputStreamReader   字符集

Read读取:字符、字符数组(或一部分)、不能直接读取字符串,

但可以使用字符数组构建字符串

 

课堂练习:

GBK  -->  中文一段话

读取文件

同时,按照utf-8字符集写入文件

 

 

缓冲字符流:

PrintWriter      BufferedReader  

对字符流进行的包装

也可以直接对字节流进行包装

也可直接使用,不需要包装

Print    println

 

FileInputStream  -->  文件复制,配合缓冲字节流使用

ObjectInputStream  -->  读写对象,不仅能写到文件中,还能在客户端之间传

InputStreamReader -->  字节流 - 字符流的转换

BufferedReader  -->  读写文件

BufferedInputStream   缓冲字节流

RandomAccessFile  对文件进行随机访问

 

 

 

 

 

复习:

API   常用类、接口、方法

使用方法前要先有对象

1、创建对象方式

2、方法的用法、作用

String:1、String str=“hello”

  2、String str=new String(“hello”)

  3、String str=new String(char[]);

  4、String str=new String(byte[] );

  5、String str=StringBuilder sb.toString( );

matches(String redex);              split(“”);

indexOf( );        charAt( );     replace( );

StringBuilder :append();   revese();  

Date:1、Date date=new Date();

2、Date date=new Date(long time);

3、Date date=Calendar c.getTime( );

Calendar:Calendar c=Calendar.getTnstance( );

c.gettime();    c.settime();

c.add();

SimpleDateFormat  sdf: .format(Date date);

Date date = sdf.parse(String str);

Collection 接口

接口 Collection c=new 实现类();

Collection c=new 实现类(Collection c);

.add();    .size();     .contains();      .isEmpty();    .clear()

List 接口

List list=new 实现类();

List list=new 实现类(List list);

Set 接口

Set set=new 实现类();

Set set=new 实现类(Set set);

Map 接口

Map map=new实现类();

Map map=new 实现类(容量16,加载因子0.75); 

 

回顾:

File file=new File();

creatNewFile()

makdir()

delete()

...获得各种属性

 

InputStream

FileInputStream   字节流(文件复制)

BufferedInputStream

Reader      Writer

InputStreamReader

 

BufferedReader         PrintWriter

ObjectInputStreamReader

Serializable

序列化、反序列化、持久化

数据结构(对象)转换成字节

字节转换成对象

字节存储在文件

RandomAccessFile

Seek  getFilePointer    skipBytes

 

Properties

load() 添加文件

getProperty(key)

 

 

=============================================================

项目练习: 

在线考试系统:

1、Paper:

String title

题目Question(类)   Set<Question>

Date date;

2、Question

属性:题干(String body)、选项(List<String>/Map<Character,String>)、标准答案(char);

int scoreItem(每一题的分数);

3、AnswerPaper:

List<Character> answers;

4、Student

String name;

String id;

int score;

 

=============================================================

异常:Exception 所有异常的父类

1、已检查异常:planB  必须要try-catch处理,在代码当中处理

未检查异常(运行时异常):(eg:空指针异常)

程序出错,需要处理(改)代码,不同try-catch处理    RuntimeException

5中未检查异常:NullPointerException 空指针

ArrayIndexOutOfBounds  数组越界

 ClassCastException 当试图将对象强制转换为不是实例的子类时,抛出该异常

NumberFormat...数值转换异常

EgString s=abc”;

Int i=Integer.parseInt(str);

ConcurrentModificationException  线程同步异常

try{正常逻辑}

catch{意外、异常}

finally{一定运行到的语句块}

通常用来释放资源《强制退出system.exit(0)不会运行》

 

2、API提供的异常有限

所以关于业务逻辑的异常,需要自己定义

通常是已检查异常,直接继承Exception即可

3、处理异常的原则:

A、谁产生,谁处理

B、自己解决不了的,就往上抛

最上层解决--调用者

C、已检查异常,一定要处理

 

 

扩展:

1、标注: 注解 Annotation

@Override

注释:给程序员、给使用者,不会出现在class文件,对程序没有影响

注解:给编译器、虚拟机,会影响程序

2、Error     Exception

异常可以解决,错误一般是程序员解决不了的


本文出自 “Java学习” 博客,请务必保留此出处http://12181171.blog.51cto.com/12171171/1960300

以上是关于Java基础部分笔记(学习流程)的主要内容,如果未能解决你的问题,请参考以下文章

javascript语法基础_java教程

Java基础部分全套教程.

Java基础部分全套教程.

Java基础部分全套教程.

Java基础部分全套教程.

UE5学习笔记——蓝图基础之基础节点知识