corejava学习总结

Corejava学习总结

内容目录

第一章 面向对象编程 ............................................................................................................................................. 2 1.0面向对象概念 ................................................................................................................................................ 2 1.1 类的定义 ....................................................................................................................................................... 2 1.2.类的实例化 .................................................................................................................................................. 3 1.3.类的成员 ........................................................................................................................................................ 3 1.4.类的访问控制 ................................................................................................................................................ 4 1.5.类的三大特性 ................................................................................................................................................ 5 1.6.super和this关键字 ....................................................................................................................................... 7 1.7 关键字static, final和abstract ...................................................................................................................... 8 1.8 抽象类和接口 ............................................................................................................................................... 9 抽象类： ...................................................................................................................................................... 9 接口： ........................................................................................................................................................ 10 接口重写 .................................................................................................................................................... 12 类的修饰符 ........................................................................................................................................................ 14 1.9(1)内部类 ...................................................................................................................................................... 14 1.9.1成员内部类 ........................................................................................................................................ 14 1.9.2静态内部类 ........................................................................................................................................ 15 1.9.3局部内部类 ........................................................................................................................................ 15 1.9.4匿名内部类 ...................................................................................................................................... 16 1.9(2)字符串和包装类 ...................................................................................................................................... 18 字符串 ........................................................................................................................................................ 18 包装类 ........................................................................................................................................................ 19 第二章 集合框架 ................................................................................................................................................... 20 2.1 集合 ............................................................................................................................................................. 20 2.1.1集合的理解 ........................................................................................................................................ 20 2.1.2为什么要使用集合 ............................................................................................................................ 20 2.1.3 Collection 接口和Collections类 ..................................................................................................... 20 2.1.4 List ..................................................................................................................................................... 20 LinkedList: .................................................................................................................................................. 21 2.1.5 Set ...................................................................................................................................................... 22 2.1.6 Map .................................................................................................................................................... 23 2.1.7 toString(),equals(),hashCode() .................................................................................................................. 25 第四章 泛型 ........................................................................................................................................................... 26 4.1 为什么要使用泛型 ..................................................................................................................................... 26 4.2泛型的使用 .................................................................................................................................................. 27 第五章 正则表达式 ............................................................................................................................................... 28 5.1 正则表达式的应用 ..................................................................................................................................... 28 第六章 异常 ........................................................................................................................................................... 29 6.1 Exception ...................................................................................................................................................... 29 6.2自定义异常 .................................................................................................................................................. 30

6.4 printStackTrace()和printStackTrace(PrintWriter out) ................................................................................. 31 6.5 异常链 ......................................................................................................................................................... 32 第七章 多线程 ....................................................................................................................................................... 32 6.1 进程与线程的区别 ..................................................................................................................................... 32 6.2 同步与异步 ................................................................................................................................................. 32 6.3 并发与并行 ................................................................................................................................................. 32 6.4 java中的线程 .............................................................................................................................................. 32 6.5 Thead与Runnable接口实现线程的区别与联系 ...................................................................................... 33 区别: ................................................................................................................................................................... 33 6.6 后台线程 ..................................................................................................................................................... 36 6.7 线程的让步 ................................................................................................................................................. 36 6.8 强制线程运行 ............................................................................................................................................. 37 6.9线程的同步,异步和死锁 ............................................................................................................................. 37 第八章 IO操作 ...................................................................................................................................................... 42 8.1 文件 ............................................................................................................................................................. 42 8.2 字节流 ......................................................................................................................................................... 42 8.3 字符流 ......................................................................................................................................................... 46 8.4 序列化与反序列化 ..................................................................................................................................... 46 第九章 网络编程 ................................................................................................................................................... 48 第十章 反射 ........................................................................................................................................................... 49 10.1反射的理解 ................................................................................................................................................ 49 10.2 反射的作用 ............................................................................................................................................... 49 10.3 反射的使用 ............................................................................................................................................... 49 第十一章 注解(Annotation) ................................................................................................................................. 55 11.1 注解的概念 ............................................................................................................................................... 55 11.2 注解的使用 ............................................................................................................................................... 55 11.3 定义注解 ................................................................................................................................................... 55 11.4元注解 ........................................................................................................................................................ 55

第一章 面向对象编程

1.面向对象概念

什么叫对象？

万物皆对象，一个人你可以把它看作是一个对象。大家找女朋友或男朋友的时候，那个女朋友或男朋友就可以看作是你的对象。

什么是类？

类是对象抽象，是从一类对象中抽象出来的共同点。

类和对象的关系？

类是对象的模板，类是对象的抽象，对象是类的实例。

使用面向对象的思维编程有哪些好处？

1. 类的定义

怎样去定义一个类？

[modifier] class classname{ }

一个类能够定义为public，package private(默认) 的。

//类体

1..类的实例化

怎样去实例化一个类

类名 引用名 = new 类名(); 示例：

public class Person{}

Person p = new Person();//类的实例化

类实例化的三个步骤：

1.为对象分配内存空间。 2.为成员属性赋值。 3.调用构造方法。

1..类的成员

示例：

public class Person｛

private int height;//属性 private int weight; private int age; private String name;

public void sleep(){//类和行为 }

class Koo{//内部类

int i = 1; public void test(){

｝

}

}

属性：描述类的特征。

修饰属性的修饰符和方法所能用的修饰符是一样的。

用static 修饰的是静态变量，又称为类变量。在所有的类的实例之间是共享的。 用static final修饰的成员属性称为常量。常量一经初始化就不能被修改。 常量有两种初始化方式： 1.定义时直接初始化。

2.定义之后，在静态代码块中初始化。

用final修饰的成员属性称为最终变量，它初始化后就不能再更改了。 它有两种初始化的方式： 1.定义时直接初始化。 2.在构造方法中初始化。

不是用static final,static修饰的成员属性，你如果在定义它的时候，没有给它初始化，系统会以它们相应类型的默认值来给它们初始化。如:int 会初始化0,boolean 为 false,引用类型会初始化为null 等。

private int height;//属性 private int weight;//属性 private int age;//属性 private String name;//属性 这些描述一个人的基本特性。 属性有三种赋值方式：

1.定义时就赋值 2.通过构造方法赋值 3.在成员方法中赋值

方法：类的行为

public void sleep(){//类和行为 }

可以用来修饰方法的修饰符有：static,final,static final,public, private ,protected,abstract。

用static修饰的方法是静态方法，不属于任何对象，只属于类本身，在所有对象之间是共享的。在访问的时候，使用 类名.方法名 的形式去调用。

内部类：在类内部定义的类。

class Koo{//内部类 }

int i = 1; public void test(){ }

1.类成员的访问控制

修饰符 Public protect default(默认的) private

类内 √ √ √ √ 包内 √ √ √ × 子类 √ √ × × 包外 √ × × × 1..类的三大特性

封装：就是以一种固有的形式把类提供给外部使用的方式。让外部只能使用类的实例来访问类的内部

行为和属性。封装提高了数据的安全性，使用者不必关心它内部的细节。

封装就是把一类相同的特征和行为合并为一种数据类型，这种数据类型就称为类。

继承：一个类继承另一个类，继承的类称为子类，被继承的类称为父类。一个类没有明确的声明它的父类，则默认继承java.lang.Object。Object类是所有java类的直接或 间接父类。Object类中所有方法者将被它的子类继承。

java中只支持单继承，一个父类可以有多个子类，一个子类只能有一个父类。

子类在实例化的时候，会自动调用父类的构造方法，使用super()或super(args) 来调用父类的构造方法，它必须放在子类构造方法中的第一行.如子类中没有super方 法，系统会自动加上super方法。

(new A()).new B();

在内部类里访问外部类的成员：

A.this.a;

private abstract class A{}//这个类前面的修饰符private abstract有什么 含义？

加上private ，是让这个内部类不能在外部类的外面被访问，只能在这个类的 内部使用，这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。 加上abstract，是让这个内部类不能被实例化，只能让实现了它的子类去实 例化。 private abstract一起使用，是为了让这个类在外部类的外面不能不使用，同时在类的内部不能被实例化。

1.9.2静态内部类

用static 关键字修饰的内部类。

静态内部类的修饰符可以是：private， protected， public，protected ，abstract,static,final static。abstract不能和final，以及和static final一起使用。 public class A{static class B{}//静态内部类} 静态内部类的实例方式：

new A.B();//因为是静态的，所以不要new外部类的实例

静态内部类只能访问外部类的静态成员。

1.9.3局部内部类

像局部变量一样，不能申明为public,protected,private和static.它的使用域只在 定义它的方法内可以修饰内部类的修饰符有:final,abstract, final和abstract不能一起使用。

只能访问它所在方法里面用final修饰的变量，非final修饰的变量不能被访问，会报错误。 public class A{

部。

public void a(){

int w = 10; final int f = 10; class C{//局部内部类

//int c = w;//错误,不能访问非final类型的变量 int c = f;//正确 }

class B{}//局部内部类

abstract class C{}//可以用abstract修饰

final class D{}//可以用final 修饰,里面的成员不是final类型的

}

}

1.9.4匿名内部类

没有class关键字，没有extends，implements关键字，没有构造方法， 隐藏的继承一个父类或实现一个接口。

class B{ public test(){ }

Comparator com=new Comparator(){//用匿名内部类实现java.util.Comparator比较器 @Override };

public int compare(Object o1, Object o2) { }

return 0;

匿名内部类特殊的局部内部类。

}

内部类，前面可以用private修饰，局部内部类不能用private 来修饰， 一个类的内部可以定义接口，一个内部类(包括局部内部类)可以用final,abstract来修饰，局部内部类不能定义为静态的。

示例：

import com.summary.staticandinnerclass.StaticDemo1.Goo; //private class StaticDemo1 {//修飾符不能是private public class StaticDemo1 {

public static void main(String[] args) { }

Koo koo = new StaticDemo1.Koo();//靜態內部的類的初始化方式 Goo goo = new StaticDemo1().new Goo();//非靜態內部類初始化方式 A a = new A(){//接口 的实现方式 public void test() { };

System.out.println(\ }

public static void a(){

static int a = 0;//局部变量不能定义为静态的

final class Foo{////正确的 , 它里面的成員不是final的，只有在成員前面加上final修

// //

飾符 // // // //// // // // // // // // // //

}

}

int a = 9; final int b = 10; public void test(){ }

b =12;//错误的

a = 11;//正确的

System.out.println(\ System.out.println(\

Foo foo = new Foo(); foo.test();

static class Foo{//错误的， 不存在局部靜態內部類 }

abstract class Foo{//正确的 public abstract void test(); }

class Joo extends Foo{ }

Joo joo = new Joo(); joo.test();

public void test() {

System.out.println(\); }

private static class Koo{//内部类，前面可以用private修饰，局部内部类不能用private 来

public void test(){ }

public static void say(){ }

System.out.println(\); System.out.println(\);

修饰

}

class Goo{//非靜態內部類里面不能有靜態變量和方法

public static int a = 9;//錯誤

public void test(){ }

public static void say(){//錯誤 System.out.println(\ }

System.out.println(\);

//

// // //

}

}

class Doo extends Goo{ }

public void test(){ }

System.out.println(\);

private class Hoo{//它的前面的修飾可以是private，外部類前面的修飾符不能是private }

interface A{//在一个类的内部可以定义接口 void test(); }

A a = new A(){

@Override

public void test() {

System.out.println(\);

}};

Goo goo = new Goo(){ };

public void test(){ }

System.out.println(\);

class TestInnerClass1{

public void test(){

StaticDemo1.Goo goo = new StaticDemo1().new Goo();//在一個內部類的外部類外面創

建內部類的實例 Goo doo = new StaticDemo1().new Doo(); }

}

1.9(2)字符串和包装类

字符串

String:定长字符串，是final类型的，不可被继承。(不变模式)

String s = “abc”和 String s = new String(“abc”);的区别：

第一种方式：字符串是放在字符串常量池中,每一次都是引用的同一个字符串。

第二种方式：字符串是存放堆区，每次用这种方式创建字符串对象，就会在堆区产生 一个新的对

象。

}

//String 是final类型，不能被继承

public static void main(String[] args) {

String s1 = \;

String s2 = \;//非实例化出来的字符串是放在常量池中的，s1和s2引用的是同一个地址 System.out.println(s1 == s2);//true//s1,s2引用的是同一个字符串地址 System.out.println(s1.equals(s2));//

String s3 = new String(\); String s4 = new String(\);

System.out.println(s3 == s4);////显然内容相同，但是地址不同 System.out.println(s3.equals(s4));////比较的是内容，内容相同 String s5 = s3;//指向s3所指向的字符串,地址一样 System.out.println(s5 == s3);////地址相同

示例：

public class StringDemo1 {

System.out.println(s5.equals(s3));////内容一样 }

在用String做字符串拼接时，由于String是final类型的，值是不能被改变，每拼接一次，可能都

会产生一个新的字符串，这样就造成了内存资源的浪费，所以在做字符串拼接操作时，尽量不使用String类型来做，而使用StringBuffer 和 StringBuilder来做。

和 StringBuilder

StringBuffer 和StringBuilder是可变长的字符串。 StringBuffer 和stringBuilder的比较

线程安全 执行效率 StringBuffer 线程安全 较高 StringBuilder 非线程安全 高

包装类

中八种基本类型都有它们各自的包装类型。 Integer：int型的包装类。

4.装箱与拆箱

装箱：

public static void main(String[] args) {

List list = new ArrayList(); list.add(1); list.add(2); list.add(3);

Object obj = list.get(0);

//String s = list.get(1);//错误的,这个时候会进行 类型安全检查，Integer不能转换为

String类型,出现下面的异常:// //Exception in thread \java.lang.Error: Unresolved compilation problem: }

}

//Type mismatch: cannot convert from Integer to String

从上面的例题中可以看出，泛型可以解决类型的安全性问题，其主要原理是在类声明时过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这样在类的声明或实例化时只要指定好需要的类型即可。

4.2泛型的使用

泛型对象的定义：

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

Shop petShop = new Shop(new Pet(\旺财\ ));

package com.tarena.day15; public class ShopDemo{ }

class Shop

{ }

class Pet{

P product; public Shop(){} public Shop( P p){ }

public P buy(){ }

return product; this.product = p;

public static void main(String[] args){ }

Shop petShop = new Shop(new Pet(\旺财\ )); //petShop.product = new Toy(\伍通\ Pet dog = petShop.buy(); System.out.println(dog);

}

String name;

public Pet(String name){ }

public String buy(){ }

return name; this.name = name;

class Toy{ }

String name;

public Toy(String name){

this.name = name; }

public String buy(){ }

return name;

泛型类定义:

class Shop

{//这个里面也可以指定多个泛型标识:,泛型的标识没有限定的，可以是任意的 }

//标识符号

P product;//此变量的类型由外部决定 public Shop(){ }

public Shop( P p){ //里面的参数类型由外部决定 this.product = p; }

public P buy(){ //返回值类型外部决定 return product; }

第五章 正则表达式

5.1 正则表达式的应用

验证邮箱地址是否正确:

package com.summary.regex; import java.util.Scanner;

import java.util.regex.Pattern; import java.util.regex.Matcher; public class RegexDemo {

}

public static void main(String[] args) {

Scanner console = new Scanner(System.in);

//Pattern 正则表达式的编译表示形式

Pattern pattern = Pattern.compile(\9]{0,}\\\\.[a-zA-Z]{2,3}\);

System.out.println(\请输入邮箱地址：\ );

//Matcher 通过解释 Pattern 对字符序列执行匹配操作的引擎

//通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它 //执行三种不同的匹配操作：

//matches 方法尝试将整个输入序列与该模式匹配。 //lookingAt 尝试将输入序列从头开始与该模式匹配。

//find 方法扫描输入序列以查找与该模式匹配的下一个子序列。 //每个方法都返回一个表示成功或失败的布尔值。

Matcher match = pattern.matcher(console.nextLine()); boolean ismatched = match.matches(); if(ismatched){ }

System.out.println(\你输入的邮箱是合法的！\ ); }else{

System.out.println(\你输入的邮箱是不合法的！\ ); }

java中的正则表达式

Pattern pattern = Pattern.compile(\ {0,}\\\\@[a-zA-Z0-9]{0,}\\\\.[a-zA-Z]{2,3}\);

System.out.println(\请输入邮箱地址：\ );

Matcher match = pattern.matcher(console.nextLine()); boolean ismatched = match.matches();

第六章 异常

6.1 Exception

是所有异常类的父类，它继承自Throwable。 异常分为非检查异常和检查异常

RuntimeException: 非检查异常，是在java 虚拟机正常运行时抛出的异常的类的超类。非检查异常无需用throws在方法后面进行声明。你可以用try catch语句捕捉，也可以不用。

检查异常：就是除RuntimeException异常及子类以外所有异常类,这类异常需要用throws在方法

后面进行声明或用try catch语句进行捕获。它在程序被编译时，系统就会检查这种异常。如果在程序中不处理这类异常，编译就不会通过。这类异常是必须做相应处理的。

在线程的run方法里面可以申明或抛出非检查异常，而不能申明检查异常，能抛出检查异常(run方法中必须有try...catch块进行处理，且不能用申明异常的方式抛给它的 调用者)。

class ThreadDemo extends Thread{ }

int a = 4;

public void run()throws RuntimeException{ }

if(a > 3)

try {

throw new Exception(\大于4！\ );//这个异常必须用try...catch块 //进行处理 } catch (Exception e) { }

e.printStackTrace();

throws Exception:跟在方法的后面，是进行异常声明的，表示这个方法里面

可能有异常，也可能没有。如果这个方法里面产生了异常，有try catch 语句块就交给它处理，否则，交给throws Exception 来处理,它再交给它的调用者去处理。

throw new Exception():抛出异常对象（实例）

try{

//在运行过程中可能抛出异常的语句块

}catch(Exception e){//捕获异常

//产生异常时的处理代码写在这里面 e.printStackTrace();

}finally{//不管是否产生了异常，这个里面的语句都会执行 }

System.out.println(\你被out了！\

6.2自定义异常

public class MyException extends Exception{

public MyException(String message){

super(message);//调用父类的构造方法。

} }

如何抛出自定义异常：

public class TestMyException{

public static void main(String[] args){ int a = 2; try{

if( a > 0){ //假如a大于0,就抛出异常

throw new MyException(\出错啦！\

}

}catch(MyException e){

e.printStackTrace();//这个地方错误提示在正式编程中应

该把设置的人性化些。

} } }

6.3异常的限制

覆盖一个方法时，只能产生已在方法的父类中定义的异常。这是一个重要的限制，因为它意味着与父类协同工作的代码也会自动应用于从父类派生的任何对象（当然，这属于基本的OOP概念），其中包括异常。 示例：

package com.summary.exception;

import java.io.FileNotFoundException; import java.io.IOException;

public class ExceptionDemo3 { }

class A{ }

class B extends A{

// public void test() throws Exception{}//错误，子类方法后面声明的异常必须是所覆盖的父类

public void test() throws IOException{} public static void main(String[] args) {}

中的方法所声明异常类或者是它的子类。

// public void test() throws IOException{}//正确

// public void test() throws FileNotFoundException{}//正确 public void test(){}//默认继承了父类的异常声明方式 }

6.4 ()和printStackTrace(PrintWriter out)

p() 它是把错误打印到控制台。

printStackTrace(PrintWriter out)是把错打到输出到打印流中。

示例：

package com.summary.exception; import java.io.FileNotFoundException; import java.io.PrintWriter; public class ExceptionDemo { }

public static void main(String[] args){ test();} public static void test(){ }

int a = 3;

PrintWriter out = null; try {

out = new PrintWriter(\创建一个打印流对象 if(a > 1){throw new MyException(\出錯了！\

else{throw new IllegalArgumentException(\不大于1！\

} catch (FileNotFoundException e1) {e1.printStackTrace(); }catch(MyException e){

e.printStackTrace(out);//会把错误输出到exception.txt这个文件中去 out.flush();

}finally{ out.close();}

6.5 异常链

第七章 多线程

6.1 进程与线程的区别

进程是一个应用，它是独占所分配的资源的，是的不会和其它的进程去共享的。例如，

我们使用QQ聊天时，QQ就是操作系统的一个进程，这个时候也你可能会去打开浏览器，去看下新闻或者其它什么的。这个时候浏览器也成为了操作系统里的另外一个进程，操作系统会为QQ和浏览器分配各自所要资源，它们之间的资源是不会共享的。

线程是一个应用为了去完成某种特定任务而去执行的程序片段。它包含在进程之内，线程与线程之间是共享资源的。例如，我们去打开一个或多个QQ聊天窗口时，QQ这时就会为我们启动一个或几个QQ聊天窗口线程。一个浏览器中可能会打开多个标签页，这时也就启动了几个线程。

6.2 同步与异步

同步： 一个线程必须等到另一个线程把所占有的资源使用完了之后，才能接着去使用这个资源

异步：两个线程在同一时间点去抢同一个资源。

6.3 并发与并行

并发：

在一个时间片内有一个以上的线程在运行

并行：

同一个时间点中有一个以上的线程在运行

6.4 java中的线程

实现线程的三种方式： 1.继承Thread类 示例：

package com.summary.thread;

public class ThreadDemo extends Thread{

public static void main(String[] args) { }

Thread t = new Thread(); t.start();

}

public void run(){

System.out.println(\一个线程在运行了。\ ); }

2.实现Runnabel接口 package com.summary.thread;

public class RunnableDemo implements Runnable{ }

@Override

public void run() {//线程体

System.out.println(\这是通过实现Runnable接口而产生的线程！\ ); }

public static void main(String[] args) {

RunnableDemo rd = new RunnableDemo();

Thread t = new Thread(rd);//需要把实现Runnable接口的实例化对象做为参数传入

t.start();//启动线程 }

3.使用匿名内部类实现线程： new Thread(){

public void run(){ }

System.out.println(\内部类实现线程方式1！\

}.start();

new Thread(new Runnable(){ });

public void run(){ }

System.out.println(\内部类实现线程方式2！\

6.5 Thead与Runnable接口实现线程的区别与联系

区别:

通过继承Thread来实现的线程之间，是不能共享资源的，而通过实现Runable接口来实现的线程之间

是可共享资源的。具体请下面的示例：

package com.summary.thread;

public class TicketsThreadDemo extends Thread{ }

private int tickets = 4;//票数

public static void main(String[] args) { }

TicketsThreadDemo ttd1 = new TicketsThreadDemo(); TicketsThreadDemo ttd2 = new TicketsThreadDemo(); TicketsThreadDemo ttd3 = new TicketsThreadDemo(); ttd1.start(); try { }

ttd2.start(); ttd3.start();

Thread.sleep(100);

// TODO Auto-generated catch block e.printStackTrace();

} catch (InterruptedException e) {

public void run(){ }

while(true){ }

if(tickets > 0){

tickets--;

System.out.println(\ + tickets); break;

}else

执行结果：

tickets : 3 tickets : 2 tickets : 1 tickets : 0 tickets : 3 tickets : 3 tickets : 2 tickets : 2 tickets : 1 tickets : 0 tickets : 1 tickets : 0

package com.summary.thread;

public class TicketsRunnableDemo implements Runnable{ }

@Override

public void run() { }

while(true){

if(tickets > 0){

tickets--;

System.out.println(\ + tickets); break;

private int tickets = 4;//票数

public static void main(String[] args) { }

TicketsRunnableDemo trd = new TicketsRunnableDemo(); Thread t1 = new Thread(trd); Thread t2 = new Thread(trd); Thread t3 = new Thread(trd); t1.start(); try { }

t2.start(); t3.start();

Thread.sleep(100);

// TODO Auto-generated catch block e.printStackTrace();

} catch (InterruptedException e) {

}else

}

执行结果：

tickets : 3 tickets : 2 tickets : 1 tickets : 0

联系：

下面我们来看下Thread类的源码：

public class Thread implements Runnable {//Thread类实现了Runnable接口 private Runnable target; public Thread() {

init(null, null, \ + nextThreadNum(), 0);

本文来源：https://www.bwwdw.com/article/f2mg.html