Java基础学习笔记

来源：互联网发布：网络剧营销创意编辑：程序博客网时间：2024/06/01 17:42

Java学习笔记

Java面向对象

方法创建和重载

1.方法的定义

方法：方法是一段可重复调用的代码段

定义格式：

访问修饰符放回类型值方法名(){

方法主体

}

2.方法的重载：

方法名称相同，但是参数的类型和个数不同，通过传递参数的个数和类型不同来完成不同的功能

类的定义、声明及使用

1.类：

类是对某一类事物的描述，是抽象的、概念上的意义。

class类名称{

属性

方法

}

声明一个类需要通过class关键字

2.对象：

对象是实际存在的该类事物的每一个个体，也被称为对象或实例

内存划分：

也就是说，对象存储在栈中，它指向堆中的一个内存空间，堆中存储着它的内容。

对象.属性可以为属性赋值；

对象.方法可以调用对象中的方法。

3.面向对象三大特征：

封装性：对外不可见

继承：扩展类的功能

多态性：

方法的重载

对象的多态性

4.方法的递归

递归：递归调用是一种特殊的调用形式，就是方法自己调用自己。

封装性

1.封装性产生的目的：

保护某些属性和方法不被外部所看见

2.封装性的实现：

方法和属性通过关键字private来声明

实现该属性的set和get方法，为外部所访问

编程技巧：在声明完一个类中的所有private属性后，可以右键，source—generate getter and setter自动生成set和get方法

3.构造方法：

格式：

访问修饰符类名称(){

程序语句

}

注意点：

构造方法名称必须与类名一致

构造方法没有你返回值

构造方法主要是为类中的属性初始化

每个类在实例化之后都会调用构造方法，如果没有构造方法，程序在编译的时候会创建一个无参的什么都不做的构造方法

4.匿名对象

匿名对象就是没有名字的对象，如果程序只是用一次该对象，就可以使用匿名对象的方式

使用格式：

类名.方法

Java面向对象中的引用传递

1.整型数据引用传递示意图

2.字符串引用传递示意图

第一种方式：

publicstatic void main(String[] args) {

String str1 = "Hello";

System.out.println(str1);

tell(str1);

System.out.println(str1);

}

publicstatic void tell(String str2) {

str2 ="jike";

}

第二种方式：

class Ref2 {

String temp = "Hello";

}

publicclass Ref {

publicstatic void main(String[] args) {

Ref2 r1 = new Ref2();

r1.temp ="jike";

System.out.println(r1.temp);

tell(r1);

}

publicstatic void tell(Ref2 r2) {

r2.temp ="xueyuan";

}

3.This关键字

表示类中的属性和调用方法

调用本类中的构造方法

表示当前对象

4.static关键字

使用static声明属性：static声明全局属性

使用static声明方法：直接通过类名调用

注意点：使用static方法的时候，只能访问static声明的属性和方法

5.继承

继承的基本概念

扩展父类的功能

2.Java中使用extends关键字完成继承

Class 子类 extends 父类{}

继承的限制

在Java中指允许单继承

子类不能直接访问父类的私有成员

3.子类对象的实例化

在子类对象实例化之前，必须先调用父类中的构造方法，之后调用子类的构造方法

方法的重写

在继承中，存在着重写的概念，其实就是子类定义了和父类同名的方法

定义：

方法名称相同，返回类型相同，参数也相同

重写的限制：被子类重写的方法不能拥有比父类方法更加严格的访问权限

访问权限：private<default<public

super关键字

强行调用父类的方法的执行

Supper不一定在重写中使用，也可以表示那些方法是重父类中继承而来的

继承和重写的区别

6.抽象类与接口

1.final关键字

final关键字在java中被称为完结器，表示最终的意思

Final能声明类、方法、属性：

使用final声明的类不能被继承

使用final声明的方法不能被重写

使用final声明的变量变成常量，常量是不可以被修改的

抽象类

抽象类的概念：

包含一个抽象方法的类就是抽象类

抽象方法：

声明而未被实现的方法，抽象方法必须使用abstract关键字声明

抽象类被子类继承，子类（如果不是抽象类）必须重新抽象类中的所有抽象方法

定义格式：

Abstract class className{

属性

方法

抽象方法

}

抽象类不能直接实例化，要通过其子类进行实例化

接口

接口是Java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成

接口的格式：

Interface interfaceName{

全局常量

抽象方法

}

接口的实现也必须通过子类，使用关键字implements，而且接口可以是多实现的

一个子类可以同时继承抽象类和实现接口

一个接口不能继承一个抽象类，但是可以通过extends关键字同时继承多个接口，实现接口的多继承

面向对象多态性

多态性

多态性的体现：

方法的重载和重写

对象的多态性

对象的多态性：

向上转型：程序自动完成

父类父类对象 = 子类实例

向下转型：强制类型转换

子类子类对象 = （子类）父类实例

instanceof关键字

在Java中可以使用instanceof关键字判断一个对象到底是不是一个类的实例

8.泛型

1.认识泛型

泛型是在JDK1.5之后增加的新功能。泛型(Generic)

泛型可以解决数据类型的安全性问题，他主要的原理，是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

格式：

访问权限 class 类名称<泛型，泛型...>{

属性

方法

}

对象的创建

类名称<具体类型> 对象名称 = new 类名称<具体类型>();

构造方法使用泛型

构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定，而又需要通过构造方法设置属性内容的时候，那么构造方法的定义域之前的并无不同，不需要像声明类那样指定泛型

通配符

即在声明的时候指定类型为T：

Class Info<T>{

Private T key;

}

当用的时候再为其指定具体的类型（T可以被Java中的任意一种基本数据类型代替）

泛型接口

在JDK1.5之后，不仅仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类型的语法类似，也是在接口名称后面加上<T>

格式：

Interface 接口名称<泛型标识>{

}

泛型方法

泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据类型。

格式：

访问权限 <泛型标识> 泛型标识方法名称（[泛型标识参数名称]）

集合类

Java集合collection

Collection是一种接口，也是List和Set的父类。

它的不同的方法详见API。

Java集合List

List接口可以存放任意的数据，而且在List接口中内容是可以重复的；
List接口常用子类：

ArrayList采用异步处理方式，性能高，属于非线程安全；

声明格式如下：

List<Type> listName = new ArrayList<Type>();

添加数据:

ListName.add（Object）；

Vector采用同步处理方式，性能低，属于线程安全；

声明格式如下：

List<Type> listName = new Vector<Type>();

添加数据：

ListName.add(Object);

输出格式都是利用循环输出：

For(int i = 0;i < listName.size(); i ++){

System.out.println(ListName.get(i));

}

常用操作：

判断集合是否为空：boolean isEmpty()；

查找指定的对象是否存在：int indexOf(Object o)；

其他方法详见API。

Java集合Set

Set接口中不能加入重复元素，但是可以排序。
Set接口常用子类

散列存放：HashSET

Set<Type> SetName = new HashSet<Type>;

有序存放：TreeSet

Set<Type> SetName = new TreeSet<Type>;

添加数据都是：

SetName.add(Object);

输出格式都是：

System.out.println(s);

Java集合Iteration

集合输出的标准操作

标准做法：使用Iteration接口

操作原理

Iteration是专门迭代输出接口，迭代输出就是将元素一个个进行判断，判断其是否有内容，如果有则把内容取出。

实例化操作：

Iteration<Type> IterationName = collectionName.iteration();//此处可以是任意一种集合

输出操作：

While(IterationName .hasNext()){

String str = IterationName.next();

System.out.println(str);

}//它的作用只是迭代输出collectionName(即另一种集合)中的内容

特别注意在用Iteration输出内容的时候，一定不要用其他集合的remove方法来删除集合内的元素！

Java集合Map

保存形式：

Key——value的方式保存

常用子类：

HashMap：无序存放，key不允许重复

HashTable：无序存放，key不允许重复

声明格式如下：

Map<Type,Type> MapName = new HashMap/HashTable<Type,Type>();

添加数据：

Map.put(key,values);

文件操作

1.遍历文件夹

步骤：

创建一个遍历文件夹的类；

判断传入对象是否为文件夹；

如果是，则创建一个数组用于接收文件夹的内容；

用循环输出文件夹的内容，在此循环中可以加一个循环用于显示文件夹层级，以方便观察结果；

由于文件夹中还有文件夹存在，所以，首先输出找到的文件名，再判断是否为文件夹，若为文件夹则递归调用函数本身继续遍历。

publicclass FileDemo01 {

publicstatic void main(String[] args) {

printFile(new File("../handtest"), 1);

}

publicstatic void printFile(File dir,int tab) {

if (dir.isDirectory()) {// 判断此对象是否为文件夹

Filenext[] = dir.listFiles();// 使用数组接收内容

for (inti = 0; i < next.length; i++){//利用循环输出文件夹的内容

for (intj = 0; j < tab; j++) { //此循环用于显示文件夹的层级

System.out.print("|--");

}

System.out.println(next[i].getName());

if (next[i].isDirectory()) { // 遇到文件夹，则递归调用函数本身

printFile(next[i],tab + 1);

}

2.文件的简单读写操作

文件的读操作

步骤：

声明文件对象（此文件要存在，不然之后的操作无法进行）；

创建FileInputStream 文件字节输入流；

创建InputStreamReader 字符输入流；

创建BufferedReader 读取缓冲区；

声明字符串对象，将文件中的东西通过此字符串读取出来；

关闭三个流区，顺序为创建时的逆序；

注意在创建三个流区的时候会有异常，应将他们用Try捕获，line =br.readLine()也会有异常，应将其捕获。

publicstatic void main(String[] args) {

Filefile = new File("test.txt");

if (file.exists()) {

try {

FileInputStreamfis = new FileInputStream(file);

InputStreamReaderisr = new InputStreamReader(fis,"UTF-8");

BufferedReaderbr = new BufferedReader(isr);

Stringline;

while ((line =br.readLine())!=null) {

System.out.println(line);

}

br.close();

isr.close();

fis.close();

}catch (FileNotFoundException e) {

//TODO Auto-generated catch block

e.printStackTrace();

}catch (UnsupportedEncodingExceptione) {

//TODO Auto-generated catch block

e.printStackTrace();

}catch (IOException e) {

//TODO Auto-generated catch block

e.printStackTrace();

}

文件的写操作

步骤：

声明文件对象（此文件可以不存在，因为在创建文件输出流的时候可以自动创建文件）；

创建FileOutputStream 文件字节输出流；

创建OutputStreamWriter 字符输出流；

创建BufferedWriter 写缓冲区；

调用bw对象的write方法写入数据直至完成；

关闭三个流区，顺序为创建时的逆序；

注意在创建三个流区的时候会有异常，应将他们用Try捕获，调用bw.write()时也会有异常，应将其捕获。

try {

Filenewfile = new File("newfile.txt");

FileOutputStreamfos = new FileOutputStream(newfile);

OutputStreamWriterosw = new OutputStreamWriter(fos,"UTF-8");

BufferedWriterbw = new BufferedWriter(osw);

bw.write("fagage\n");

bw.close();

osw.close();

fos.close();

System.out.println("写入完成");

}catch (FileNotFoundException e) {

e.printStackTrace();

}catch (UnsupportedEncodingExceptione) {

e.printStackTrace();

}catch (IOException e) {

e.printStackTrace();

}

Java中的IO操作

Java IO简介

字节流：在Java中对应的类都以”Stream”结尾。

字符流：在Java中对应的类都以”Reader”或”Writer”结尾。

2.字符、字节与编码

3.使用字节流读写数据：

使用字节流读数据核心代码：

FileInputStream fis = new FileInputStream(文件名);

Byte ByteName[] = new byte[ 大小];

Fis.read(ByteName);

String StringName = new String(ByteName);

System.out.put.println(StringName );

4.使用字节流写数据核心代码：

FileOutputStream fos = new FileOutputStream(文件名);

String StringName =“要写入文件的字符串”;

Byte ByteName[] = StringName.getBytes(“UTF-8”);

Fos.write(ByteName);

编写程序时会提示异常，将其捕获即可。

5.使用字符流读写数据：

将一个文件中的数据copy到另一个文件中的核心代码：

FileInputStreamfis = new FileInputStream("java.txt");

FileOutputStreamfos = new FileOutputStream("java_new.txt");

InputStreamReaderisr = new InputStreamReader(fis,"UTF-8");

OutputStreamWriterosw = new OutputStreamWriter(fos,"UTF-8");

charinput[] = newchar[100];

intl = 0;

while ((l =isr.read(input)) != -1) {

//String inputString = new String(input,0,l);

osw.write(input,0,l);

}

isr.close();

fis.close();

osw.close();

fos.close();

需要注意的是：isr.read(数组名)返回的为int类型。而且无论是用字符流还是字节流操作文本数据，中间都得通过字符数组以及字符串进行过度，因为他们的read方法都读入的是字符数组，而输出操作则需要将字符转换成字符串输出。

6.使用带缓冲的字符流读写数据：

FileInputStream fis = new FileInputStream("java.txt");

FileOutputStreamfos = new FileOutputStream("java_new_buff.txt");

InputStreamReader isr = new InputStreamReader(fis,"UTF-8");

OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");

BufferedReader br = new BufferedReader(isr);

//BufferedWriterbw = new BufferedWriter(osw);

PrintWriter pw = new PrintWriter(osw,true);

String input;

while ((input =br.readLine()) != null) {

//bw.write(input);

pw.println(input);

}

br.close();

//bw.flush();bw.close();

pw.close();

isr.close();

fis.close();

osw.close();

fos.close();

System.out.println("done");

7.Apache工具包的引用

先创建工程目录。然后在工程目录中创建lib文件夹，将Apache工具包移入该文件夹，然后在eclipse界面建立路径，该工程就可以引用Apache包中的各种API了。详细功能可参见工具包中doc文件夹下的index.html。

Java多线程编程

线程与进程

线程：程序中单独顺序的控制流

线程本身是依靠程序进行运行的

线程是程序中的顺序控制流，只能使用分配给程序的资源和环境

进程：执行中的程序

一个进程可以包含一个或多个线程

一个进程至少要包含一个线程

单线程：

程序中指存在一个线程，实际上主方法就是一个主线程

多线程：

多线程是在一个程序中运行多个任务

多线程的目的是更好的使用CPU资源

2.线程的实现

线程的两种实现方法：

继承Thread类

实现Runnable接口

Thread类：

Thread类是在java.lang包中定义的，继承Thread类必须重写run方法

定义格式：

Public Class calssName extends Thread{

Public void run(){ //线程的操作写在里面

};

}

特别注意，在线程启动的时候一定是使用threadName.start()启动线程，而不是run方法。通过线程的run方法启动线程与通过对象调用方法一样，无法实现线程的并发。

Runnable接口

定义格式：

Public class RunnableName implements Runnable{

Public RunnableName(){};

Public void run(){ //线程的操作写在里面

};

}

通过Runnable实现Runnable接口，之后依然要通过Thread来实现线程执行。

Thread ThreadName = new Thread(RunnableName);

ThreadName.start();

3.线程的状态

创建状态：准备好了一个多线程对象

就绪状态：调用了start()方法，等待CPU进行调度

运行状态：执行run()方法

阻塞状态：暂时停止执行，可能将资源交给其他线程使用

终止状态（死亡状态）：线程销毁

4.线程的常用方法

取得线程名称getName()

取得当前线程对象currentThread()

判断线程是否启动isAlive()

线程的强行运行join()

线程的休眠sleep() //以ms为单位

线程的礼让yield()

线程的优先级

MIN_PRIORITY

MAX_PRIORITY

NORM_PRIORITY

设置格式：

ThreadName.setPriorite(Thread.MIN_PRIORITY);

线程同步

同步代码块

在代码块上加上”synchronized”关键字，则此代码块就成为同步代码块

同步代码块格式：

Synchronized(同步对象){

需要同步的代码块；

}

同步方法

除了代码块可以同步，方法也可以同步

方法同步格式：

Synchronized void 方法名称(){}

同步的实质是实现资源共享，以保证多个线程在对同一数据操作时出现违背常理的可能。

7.线程的生命周期

Java中的XML操作

1.XML数据简介

简介：XML即可扩展标记语言，标准通用标记语言的子集，一种用于标记电子文件使其具有结构性的标记语言。它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。它非常适合万维网传输，提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。

· XML是一种标记语言，很类似HTML

· XML的设计宗旨是传输数据，而非显示数据

· XML标签没有被预定义，你需要自行定义标签

· XML被涉资未具有自我描述性

· XML是W3C的推荐标准

2.XML与HTML的对比：

3.XML的特点：

4.XML的语法规则：

XML的语法规则很简单，且很有逻辑。这些规则很容易学习，也很容易使用。在XML中，省略关闭标签是非法的，所有元素必须有关闭标签

·XML标签对大小写敏感

·XML必须正确嵌套

·XML文档必须有根元素

·XML的属性值必须加引号

·XML中，空格会被保留

5.使用Java读取XML数据

DOM方式读取XML数据：

步骤：

声明DocumentBuilderFactory 以及DocumentBuilder 用来创建文档；

Builder（由DocumentBuilder 声明的对象确定）.parse用来接收外界XML文档；

使用document.getDocumentElement()读取XML根元素；

使用根元素名.getElementsByTagName()读取XML的标签元素；

使用For循环以及标签元素名.getAttribute()输出元素属性；

使用标签元素名.getChildNodes()读取每个标签元素的子节点；

使用循环将子节点的内容输出，由于getChildNodes()得到的返回值为NodeList类型,因此创建NodeList对象接收，但输出的时候会将空格和换行符作为结点输出，因此需要用If判断语句去掉不需要的结点，具体见下面代码。在使用各个方法读取数据的时候，应根据其返回值确定用什么对象接收。

//DOM

DocumentBuilderFactoryfactory =DocumentBuilderFactory.newInstance();

DocumentBuilderbuilder = factory.newDocumentBuilder();

//声明之后，就可以创建接收外界的XML文档了

Documentdocument = builder.parse(new File("languages.xml"));

//此处的Document应该使用-org.w3c.dom包中的Document类

Elementroot = document.getDocumentElement();//读取.XML中的根元素

System.out.println("cat="+root.getAttribute("cat"));

NodeListlist = root.getElementsByTagName("lan");

//读取.XML的标签元素，由于返回值为NodeList，所以声明NodeList来接收返回值

for (inti = 0; i < list.getLength(); i++) {

Elementlan = (Element) list.item(i);

System.out.println("---------------");

System.out.println("id="+lan.getAttribute("id"));

//获取元素的属性并输出

NodeListclist = lan.getChildNodes(); //获取元素的子节点

for (intj = 0; j < clist.getLength(); j++) {

Nodec = clist.item(j);

if (cinstanceof Element) {

//由于在使用当前的API解析XML的时候，也将空格作为结点进行解析了，

//所以用此判断语句过滤不需要的结点

System.out.println(c.getNodeName()+"="+c.getTextContent());

6.使用Java创建和传递XML文件：

//DOM

DocumentBuilderFactoryfactory = DocumentBuilderFactory.newInstance();

DocumentBuilderbuilder = factory.newDocumentBuilder();

Documentdocument = builder.newDocument();

Elementroot = document.createElement("Languages");

root.setAttribute("cat","it");

Elementlan1 = document.createElement("lan");

lan1.setAttribute("id","1");

Elementname1 = document.createElement("name");

name1.setTextContent("Java");

Elementide1 = document.createElement("ide");

ide1.setTextContent("Eclipse");

lan1.appendChild(name1);

lan1.appendChild(ide1); //将标签元素里的元素插入元素标签

Elementlan2 = document.createElement("lan");

lan2.setAttribute("id","2");

Elementname2 = document.createElement("name");

name2.setTextContent("Swift");

Elementide2 = document.createElement("ide");

ide2.setTextContent("XCode");

lan2.appendChild(name2);

lan2.appendChild(ide2);

Elementlan3 = document.createElement("lan");

lan3.setAttribute("id","3");

Elementname3 = document.createElement("name");

name3.setTextContent("C#");

Elementide3 = document.createElement("ide");

ide3.setTextContent("Visual Studio");

lan3.appendChild(name3);

lan3.appendChild(ide3);

root.appendChild(lan1);

root.appendChild(lan2);

root.appendChild(lan3); //将标签元素插入根节点

document.appendChild(root); //将根节点插入文档

//-------------

TransformerFactorytransformerFactory = TransformerFactory.newInstance();

Transformertransformer = transformerFactory.newTransformer();

transformer.setOutputProperty("encoding","UTF-8");

//传递XML文件必须进行的操作，和创建XML的操作一样必不可少

StringWriterwriter = new StringWriter();

transformer.transform(new DOMSource(document),new StreamResult(writer));

System.out.println(writer.toString());

//将定义好的XML文件以字符串的形式输出

transformer.transform(new DOMSource(document),new StreamResult(new File("newxml.xml")));

//将写好的XML以文件的形式输出

7.dom4j工具包的引用

先创建工程目录。然后在工程目录中创建lib文件夹，将dom4j工具包中的.jar文件移入该文件夹，然后在eclipse界面建立路径，该工程就可以引用Apache包中的各种API了。详细功能可参见工具包中doc文件夹下的index.html。

Java中的JSON操作

1.JSON简介

JOSON：JavaScript对象表示法（JavaScript Object Notation）

JOSN是存储交换文本信息的语法。

· JSON是轻量级的文本数据交换格式

· JSON独立于语言和平台

· JSON具有自我描述性，更易理解

2.JSON与XML：

3.JSON语法：

JSON语法是JavaScript对象表示语法的子集。

· 数据在键值对中

· 数据由逗号分隔

· 花括号保存对象

· 方括号保存数组

JSON值可以是：

· 数字（整数或浮点数）

· 字符串（在双引号中）

· 逻辑值

· 数组（在方括号中）

· 对象（在花括号中）

· null

Java中的Scoket通信

1.Scoket链接的建立过程

服务监听
客户端发出请求
建立链接
通信

Scoket特点：

Scoket基于TCP链接，数据传输有保障
Scoket适用于建立长时间链接
Scoket编程通常应用于即使通讯

0 0

Java基础学习笔记

Java学习笔记

Java面向对象

方法创建和重载

类的定义、声明及使用

封装性

Java面向对象中的引用传递

5.继承

面向对象多态性

8.泛型

集合类

Java集合collection

Java集合List

Java集合Set

Java集合Iteration

Java集合Map

文件操作

1.遍历文件夹

2.文件的简单读写操作

Java IO简介

Java多线程编程

Java中的XML操作

Java中的JSON操作

Java中的Scoket通信