java基础总结

总结

Java是一种编写跨平台完全面向对象，简单，安全的编程语言

path环境变量的作用：让javac和java命令可以在任意的目录下使用。

classpath环境变量的配置：让指定的class文件在任意目录都可以被访问。

 

&&和&的区别是：如果左边有false了，右边将不再执行。&:有false则false

Scanner是JDK5以后设计的用来接收键盘录入数据使用的。

Break结束当前循环，跳出当前循环

 

函数重载：在一个类中，函数名相同,参数列表不同(个数不同,对应的类型不同， 与返回值类型无关。

数组和集合的区别：数组是存储同一种类型的多个元素的容器。

面向对象：面向过程：以函数为基础，关注实现过程。

   面向对象：以对象为基础，关注实现结果。

面向对象的思想特点：

A:是一种更符合人们思考习惯的思想。

B:把复杂的事情简单化了。

C:把我们从执行者变成了指挥者。

类：   是相关的属性和行为的集合。是一个抽象的概念。

对象： 是某种事物的具体存在，具体的表现形式。

 

匿名对象：只使用一次；作为实际参数传递给方法；

封装：指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

private关键字：私有的

A:用于修饰成员变量和成员方法。

B:被修饰的内容在其他类中是不可以被访问的。只能在本类中访问

应用：

将成员变量私有化，对外提供对应的set和get方法

对其进行访问，提高对数据访问的安全性！！

 

构造方法：访问权限修饰符 类名(参数...){}-----public,private给对象进行初始化

 

特点：

A:方法名和类名相同

B:没有返回值类型

C:没有具体的返回值

(2)注意事项：

A:如果你不给构造方法，jvm会自动给你一个无参构造方法。

B:如果你给出了构造方法，那么，jvm将不再提供无参构造方法。

这个时候，你如果要使用无参构造方法：只能自己提供

构造方法重载：

其实就是构造方法接收不同的参数

 

给成员变量赋值有两种方式：

提高set赋值   p.setName("jjjj");

提高构造方法  person p2 = new person("jjjj");

 

this关键字：是一个关键字。代表当前类对象的引用。 解决局部变量隐藏成员变量问题。super是一个关键字，代表父类的存储空间标识。(可以理解为父亲的引用)

 

代码块：：就是由{}括起来的代码

定义在方法中的代码块，叫局部代码块

作用是：让变量尽可能早的从内存中消失，提高效率

 

定义在方法外的代码块，叫构造代码块

作用是：把所有构造方法中的共同内容定义在构造代码块中。

 

Static：是一个关键字。

静态的特点：

A:随着类的加载而加载

B:优先于对象存在

C:被类的所有对象共享  为什么要使用静态 没有被静态修饰的内容，其实是属于对象的特殊描述

D:可以通过类名调用

静态的注意事项：

A:在静态方法中是没有this关键字的。this是一个对象

B:静态方法只能访问静态成员。非静态都可调用

静态内容的调用：

A:被对象调用

B:被类名调用

什么时候该用static呢?

如果某个内容是所有对象共享的，就用静态修饰。

 

继承：

 

把多个类中的相同的属性和行为进行抽取，封装到一个类中，

好处： A:提高代码的复用性。 B:让类与类之间产生了一个关系，是多态的前提。

特点：

A:Java只支持单继承，不支持多继承。

为什么?如果支持多继承，就会有调用不明确的问题。

B:Java支持多层(重)继承。

 

方法重写：在子类中，方法声明(修饰符,返回值,方法名,参数列表)相同的情况。

注意事项：

a:父类中私有方法是不能被重写

b:子类方法的访问权限一定要大于等于父类的访问权限

c:静态只能重写静态。(这个不能算，因为静态跟类相关)

 

代码块

执行顺序：

静态代码块 --> 构造代码块 --> 构造方法：静态代码块只执行一次

 

final

(1)是一个关键字，可以用于修饰类，成员变量，成员方法。

(2)特点：

它修饰的类不能被继承。

它修饰的成员变量是一个常量。

它修饰的成员方法是不能被子类重写的。

 

多态：

前提：要有继承或者实现关系；要有方法的重写；父类引用或者接口指向子类

三种体现形式：类多态，抽象类多态；接口多态

多态中的成员特点：

成员变量

编译看左边，运行看左边。

成员方法

编译看左边，运行看右边。

 

多态的好处坏处：

父类引用不能不能使用子类特有功能，向下转型

可以提高代码的扩展性和可维护性

 

抽象类

多个类中存在相同的方法声明，方法体不同，只提取方法声明

一个方法只有方法声明，没有方法体，那么这个方法必须用抽象修饰

一个类中有抽象方法，类必须定义为抽象类

 

特点：

类和方法必须用abstract修饰；不能实例化；有结构方法，用于子类实例化；继承抽象类的子类要么是抽象类，要么重写所有抽象方法

 

成员特点
成员变量可以是变量，也可以是常量

有构造方法

有抽象方法，也可以有非抽象方法

 

Abstract 不能和final   private  static关键字共存

 

接口：

接口是一种规则：用interface修饰

实现方式是implements

 

特点：
接口不能被实例化

实现了接口，要么是抽象类，要么实现接口中所有的方法

成员特点

成员变量只能是常量，成员方法只能说是抽象方法，默认修饰符是public  abstract

思想特点：对外暴漏的规则，是功能的扩张，降低耦合度，接口可以多实现

 

 

类与类：继承关系    只能单继承，可以多层继承

类与接口：like a  实现关系， 单实现，多实现

接口与接口：继承关系，单继承，多继承

抽象类与接口： 接口中都是抽象类，抽象类中都不一定都是抽象

 

内部类

特点：内部类成员可以直接访问外部类成员，包括私有。外部类成员要想访问内部类成员，必须创建对象

 

成员内部类：定义在成员位置上：private  static

局部内部类：定义在方法中，要访问局部变量，必须用final   延迟生命周期

 

匿名内部类：定义在局部位置没有名字的内部类，存在一个类，抽象类，接口中

本质理解：其实这是一个继承类或者实现接口的匿名的子类对象。

New  类接口

{

重写方法

}

Object  所有类的超类

 Tostring 方法：数组等转换成字符串的一种方法

 

==和equals的比较

==  基本类型的比较： 比较的是值

引用类型的比较： 比较的是引用类型所指向的地址值

 

String 类

string类就是字符串类

字符串是常量，他们的值在创建之后不能改变

 

字典顺序比较功能

int compareTo(String str)：按字典顺序（Unicode编码顺序），如果第一个相同比较第二个，依次类推

 

JDK5以后的新特性

A:自动装箱 基本类型--引用类型

B:自动拆箱 引用类型--基本类型

 

Date：日期类。

  Date():默认指当前系统时间。

  Date(long time):根据给定的毫秒值生成一个时间。

Calendar是日历类，它可以获取任意指定日历值，然后自由组合。

Calendar是抽象类不能实例化，但是他提供了获取其实例的方法

 

集合：

 

集合和数组的区别

1、长度问题：数组固定：集合可变

2、存储元素问题：数组可以是基本类型，也可以是引用类型：集合只能是引用类型。

3、是否同一类型：数组元素类型一致：集合元素类型可以不一致。

Collection

|--List：List是Collection接口下的一个子接口，特点：元素有序，可重复。

 

|--ArrayList

底层数据结构是数组，查询快，增删慢，线程不安全，效率高

|--Vector ：

底层数据结构是数组，查询快，增删慢，线程安全，效率低

|--LinkedList

底层数据结构是链表，查询慢，增删快，线程不安全，效率高

 

到底使用谁?根据需求看

是否要安全：

是：Vector

否：ArrayList,LinkedList

查询多：ArrayList

增删多：LinkedList         如果你什么都不知道，用ArrayList。

 

|--Set： 特点：元素无序，唯一。

 

|--HashSet  底层数据结构是哈希表。它依赖两个方法：hashCode()和 equals()

hashCode():

把对象的所有成员变量值相加即可。

如果是基本类型，就加值。如果是引用类型，就加哈希值。

equals():

A:this==obj

B:!(obj instanceof Student)

C:所有成员变量的值比较。基本类型用==,引用类型用equals()

|--TreeSet：底层结构是二叉树。按照树节点进行存储和取出。

两种实现方式：

自然排序(元素具备比较性)

      TreeSet的无参构造，要求对象所属的类实现Comparable接口。

比较器排序(集合具备比较性)

TreeSet的带参构造，要求构造方法接收一个实现了Comparator接口的对象。

 

二叉树保证元素唯一 排序

A：第一个添加的数据作为根节点。

B：从第二个开始，

每一个数据从根节点开始比较，

如果大了，往右边放，

如果小了，往左边放，

如果相同，替换。

C:从根节点开始，获取数据的规则，是按照每个数据的：左，中，右原则。

Collection和Collections的区别?

Collection：是Collection集合的顶层接口，定义了Collection集合的共性方法。

Collections：是一个类，定义了针对Collection集合操作的功能，有排序，查找，反转等。

 

迭代器：

1、使用步骤

1、通过集合对象获取迭代器对象。

2、通过迭代器对象判断。

3、通过迭代器对象获取。

2、迭代器原理

由于多种集合的数据结构不同，所以存储方式不同，所以，取出方式也不。这个时候，我们就把判断和获取功能定义在了一个接口中，将来，遍历哪种集合的时候，只要该集合内部实现这个接口即可。

 

常见的数据结构：

栈：先进后出

队列：先进先出

数组：查询快，增删慢

链表：查询慢，增删快

 

泛型的好处：

A:解决了黄色警告线问题

B:把运行期间的转换异常给提前到了编译期间

C:优化了程序设计，不需要做强制类型转换了

 

增强for循环

方便了数组和Collection集合的遍历。

 

遍历List集合体系三种方式

1):迭代器

2):普通for+get

3):增强for(工作时候用)

 

Collection集合遍历两种方式

1):迭代器

3):增强for(工作时候用)

 

Map(掌握)

(1)Map是一个键值对形式的集合。它的元素都是有键和值组成。

 

(2)Map和Collection的区别?(面试题)

A:Map 是由键值对组成的集合,Map的键(key)是唯一的,值(value)可以重复。

B:Collection 是有单列数据组成的集合,它的儿子List是可以重复的，Set是唯一的。

 

(3)HashMap和Hashtable的区别?(面试题)

HashMap:线程不安全，效率高。允许null键和值。

Hashtable:线程安全，效率低。不允许null键和值。

 

Map 的两种遍历方式

1.通过键找值

2.通过键值对集合

Collection 是单列结合  map 是双列结合

异常体系：

Throwable

|--Error 严重的问题，是处理不了的。要改正代码的。

|--Exception 

非RuntimeException的，是需要处理的。编译期异常。

|--RuntimeException 不需要处理的，是需要改代码的。运行期异常。

捕获异常

基本格式：try{可能出现问题的代码}

           catch（异常的类名 变量名）{处理异常的代码}

一个try{}多个catch去处理（选我）

catch（异常类名1 | 异常类名2 | 异常类名3 ....... 变量名）

 

抛出异常：在方法内部用throw 异常对象。

 

请问final，finally，finalize三个关键字的区别。

finalize是个方法不是关键字，它是Object类中的方法，它用于垃圾回收器。 

 

final  用它修饰的类不能被继承

       用它修饰的变量就变成的常量

   用它修饰的方法不能被重写

 

finally  它是异常处理体系的一部分，一般放在它里面的代码永远会被执行

Io流

 

1、什么是递归？

在方法内部调用方法本身的现象

 

2、递归的注意事项

A：递归调用必须要有出口，否则就会死递归内存溢出。

B：递归的次数不宜过多，过多的话有可能会出现内存溢出。

C：构造方法不能递归调用。

 

IO流分类：

字节输出流  (写数据)OutputStream

字节输入流  (读数据)InputStream

 

字符流：字符输出流  (写数据)Writer

   字符输入流  (读数据)Reader

 

问题：flush()和close()的区别？

答：flush（）只刷新缓冲区流对象还可以继续使用。

close（）先刷新缓冲区，在关闭流对象，流对象不能继续使用

 

字符流只能复制文本文件，想要复制二进制文件只能用字节流。

 

基本流：能够直接读取数据

高效流: 站在基本流的基础上，提供一些特殊的功能（处理流）

 

高效字节缓冲流：bufferedinputsteram  bufferedoutputsteram

高效字符缓冲流：bufferedwriter       bufferedwriter

标准的输入输出流

System类下的--System.in  标准输入流        都是字节流

System类下的--System.out 标准输出流

 

InputStreamReader     字节流通向字符流的桥梁

OutputStreamWriter    字符流

 

打印流概述

 1、PrintStream:字节打印流

PrintWriter：字符打印流

 2、打印流特点：

A:可以写入任意类型

B:可以自动刷新，但是必须先启动，并且是使用println（），printf（），和format （）方法。

C:可以直接对文件进行写入

 

Serializable

序列化：把对象按照流一样的方式进行传输或者存储

 

3、常见的编码表

UTF-8 UTF-16 GB2312 GB18030   最常用的是GBK

 

多线程？

一个应用程序有多条执行路径

  应用程序 > 进程 > 线程 之间的关系

 

多线程的实现方式：

1，创建一个类，并继承Thread类

2，创建一个类实现Runnable接口

 

有了Thread类为什么还要有实现Runnable接口

1、避免了单继承的局限性

2、只创建了一个资源对象，更好的实现了数据的操作和分离。

 

出现重复和负数的产生原因：

线程的随机性和延迟性，同步关键字是synchronized

加锁     synchronized(任意锁对象)

{需要被加锁的代码}

 

怎么判断一段程序有没有线程安全问题？

 

1、看有没有共享资源

2、看对共享数据操作是不是多条语句

3、看是不是在多线程程序中

 

同步代码块、同步方法，静态同步方法，锁对象

同步代码块就是把 synchronized 关键字加在方法中，任意的对象

同步方法就是就是把 synchronized 关键字加在方法声明上，this对象

静态同步方法：当前类的字节码文件对象     获取方式  类名.class

 

Object类中 wait（）

让线程处于等待状态

Object类中 notify（）

唤醒单个线程

 

wait（） Object类中的方法 ，它不需要传递参数  它释放锁对象

sleep（） Thread 类中的方法， 它需要传递一个参数 它不释放锁对象

 

线程的默认优先级是（5）,范围是1-10。

网络变编程

不同地理位置的计算机通过io流传输数据

网络通信三大要素：ip地址  端口号  协议

有效端口号：0--65535  系统保留端口：0--1024

1、TCP 和 UDP协议的区别

UDP:                                                      TCP:

数据需要打包否： 需要打包               数据需要打包否：不需要

数据大小有无限制：有限制64k          数据大小有无限制：无限制

面向有无链接：无连接                        面向有无链接：有（三次握手）

可靠否： 不可靠                                   可靠否：可靠

速度快否：速度快                                速度快否：速度慢

 

Socket包装了谁：

IP地址以及端口号

 

Inetaddress类

IP地址的一个包装类，是一个实体类

 

两种协议如何创建的 Socket 服务对象

UDP协议   发送数据  DatagramSocket

  接收数据  DatagramSocket

TCP协议   发送数据  Socket

  接收数据  ServerSocket

TCP协议发送数据

1、TCP协议客户端的步骤:

A：创建发送端Socket对象，并建立连接

B：获取输出流对象，并写数据

C：释放资源

 

TCP协议接收数据

1、TCP协议服务器端的步骤：

A、创建接收端Socket对象

B、监听连接

C、获取输入流对象，读取数据并显示

D、释放资源

 

UDP协议发送数据步骤？

A：创建发送端Socket对象   （DatagramSocket）

B:创建数据，并且把数据打包

C:发送数据   （ send方法）

D:释放资源

 

UDP协议接收数据

1、UDP协议接收数据步骤

A:创建接收端Socket服务对象

B:创建接收数据包

C:调用接收的方法

D:解析数据包

E:释放资源

正则表达式       就是一个符合某种规则的字符串（Pattern类）

 

String类中public boolean matches(String regex)

判断该字符串是否符合正则表达式的规则

 

表示  .  怎么表示

\\.

 

正则表达式的切割功能

1、切割单个空格规则

" "

2、切割多个空格规则

" +"

3、切割路径的规则String str5 = "E:\\java\\20150403";

"\\\\"

 

正则表达式的叠词切割功能

 

1、切割叠词规则

  "(.)\\1+"

（d（a（b））（c））

第零组  （d（a（b））（c））

第一组  d（a（b））（c）

第二组   a（b）

第三组   b

第四组   c

 

$1表示引用第一组的内容  $2 第二组

反射

反射：在运行状态下，通过class文件对象，可以获取到该类中的构造方法，成员变量，和成员方法去使用（包括私有的）

反射是说在程序运行期间, 对于一个类来说, 可以获取他的属性和方法, 对于一个对象来说, 可以调用他的成员属性和方法.

获取字节码文件对象的方式：

1、Object类中的getClass()方法

2、通过  类名.class 去获取

3、 Class 类中的静态方法forName（String className）方法、

className这个地方要求的是传递类的绝对路径（从包名开始的路径名）

（方式三的好处是可以配合配置文件去使用）

 

1）.BootStrap Classloader: 根类加载器, 加载最基本的类, 比如lib中的rt.jar, 是最开始的加载器, 不是java语言写的

2）.Extension Classloader: 扩展类加载器, 负责加载lib/ext中的扩展类

3）.System Classloader: 系统类加载器, 负责加载java命令和classpath中的类

 

想要暴力访问用谁？   setAccessible  (true)

                      // 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();

// 赋值前
System.out.println(obj);

// 获取年龄并赋值
                        //公共的成员变量
Field ageField = c.getField("age");
ageField.set(obj, 26);

// 获取姓名并赋值
Field nameField = c.getDeclaredField("name");
//暴力访问
nameField.setAccessible(true); 
                        nameField.set(obj, "林青霞");
// 赋值后
System.out.println(obj);

//设计模式

1、单例设计模式：

(1)设计模式：

解决某类问题行之有效的方法，是一种思想，是规律的总结

(2)用来保证某个类在内存中只有一个对象

(3)保证唯一性的思想及步骤

**为了避免其他程序建立该类对象，先禁止其他程序建立该类对象，即将构造函数私有化

**为了其他程序访问到该类对象，须在本类中创建一个该类私有对象

**为了方便其他程序访问到该类对象，可对外提供一个公共访问方式

 

比如API中的Runtime类就是单例设计模式。

 

2、单例设计模式的两种方式

A:饿汉式 当类加载的时候，就创建对象。

class Student

{

private Student(){}

private static final Student s = new Student();

public static Student getInstance()

{

return s;

}

}

B:懒汉式 当使用的使用，才去创建对象。

class Student

{

private Student(){}

 

private static final Student s = null;

public static Student getInstance()

{

if(s==null) 

{

//线程1就进来了，线程2就进来了。

s = new Student();

}

return s;

}

}

3、饿汉式和懒汉式的区别：

饿汉式是类一加载进内存就创建好了对象；

懒汉式则是类才加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，

对象才开始创建。

懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题

可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，

所以可以加双重判断来提高程序效率。

 

注：开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题