Java基础知识总结
JAVA基础知识总结
第一章 Java入门：
1.java诞生：
1995年5月23日Sun公司发布了jdk1.0版本；作者：James Gosling.
JAVAME微型版
手机软件开发
JAVASE标准版
桌面应用程序
JAVAEE企业版
企业级应用开发
2.java语言特点：
1.简单
没有C、C++中的头文件，指针，运算符重载
2.面向对象
可以开发出较大型的应用程序
3.分布式
通过网络访问应用程序，突破空间限制
4.健壮性(编译时错误检测)
消除有出错倾向的状态：指针
5.安全性(蠕虫病毒)
禁止运行时堆栈溢出、内存空间未授权读写
6.可移植性
JVM
3. JAVA的特性、核心机制：
特性：封装：对外部不可见，保护类中的操作不被外部直接访问
属性私有化，提供公共的get、set方法
封装的好处：
1.数据更安全，可以在方法内增加验证
2.可以让调用者不去关心实现的细节，重用
继承：扩张类的功能
多态：
是允许将父对象引用一个子对象的技术
E mployee employee = manager;
允许父类对象来引用子类对象，但是实际运行过程中调用的是子类的方法或者属性
编译时调用父类方法，运行时调用的是实际引用类型的方法，这种现象叫做动态绑定
多态现象：运行时多态、编译时多态
1.编译时多态：方法的重载(不建议举例)
2.运行时多态：方法的覆盖(建议举例)
核心机制：虚拟机(JVM java virtual machine) 垃圾回收机制garbage
collector
4.JDK:（Java Development Kit）1995年SUN公司JDK1.0 98年JDK1.2 接下来是JDK1.3 1.4 目前JDK1.5已经更名为JAVA
5.0 正在使用的是java
6.0版本. JDK安装目录介绍：
Bin 编译器和工具
Demo 演示
Docs HTML格式的类库文档
Include 用于编译本地方法的文件
Jre java运行环境文件
Lib 类库文件
Src 类库源文件
5.Java运行环境变量配置：
JAVA_HOME：JDK安装目录，方便在后面两个环境变量的配置中直接被
调用即可
path：%JAVA_HOME%\bin 列出可执行文件的搜素路径
classpath：%JAVA_HOME%\lib\tools.jar
%JAVA_HOME%\lib\dt.jar
.（当前路径）
是java加载类的路径，只有在classpath设置的路径中的类才能被加载6.Java中注释：
1.单行注释：
//
2.多行注释：
/* */
3.文档注释
/** */
通过javadoc命令将文档注释提取出来生成java帮助文档：Java的三种注释：7.Class 与public class区别：
如果一个类声明的时候使用了public进行声明，则类名称必须与文件名称完全一致，如果类的声明使用了class的话，则类名称可以与文件名称不一致，但执行的时候肯定执行的是生成后的类名称。
第二章标示符，运算符
1.标示符：在java语言中用来给一个类、变量或方法命名的符号
标示符的命名规则：
1.以字母, “_”或“$”符号开头
2.可以包含字母、“_”、“$”和数字符号
3.大小写敏感
4.不能与保留关键字冲突
5.没有长度限制
Java中命名规范：
1.类名, 接口名：每个单词的首字母应该大写
2.字段、方法以及对象：第一个单词首字母应小写，其他单词首字母大写
3.常量：全部用大写字母表示
4.Java包（Package）：它们全都字母小写
5.命名要做到见名知意
2.运算符：
1.算数运算符：
2.自增，自减运算符：
3.关系运算符：boolean型运行结果 true false
4.逻辑运算符：&& || !
支持短路运算
&&：左边表达式为false，右边表达式不会被执行
||：左边表达式为true，右边表达式不会被执行
5.赋值运算符：= 不要将其与（= =）等号运算符混淆
6.运算符： & 、|、 ~、 ^、 <<、 >> 、>>>
1.~ ：取反。1变0,0变1
2.&：按位与。有0为0
3.^：按位异或。相同为0，不同为1
4.|：按位或。有1为1
7.instanceof运算符：左面操作一个对象，右面操作一个类，当左面对象是右面的类创建时，该运算符的结果是true，否则是false。
第三章表达式，语句：
1.表达式：算术表达式关系表达式逻辑表达式赋值表达式
2.语句：方法调用语句表达式语句复合语句控制语句 package和
import语句
控制语句：1.条件控制语句 if if-else
2.switch开关语句 switch(){case}
switch case:
说明：
1.表达式expression可以是以下四种基本数据类型和枚举类型(byte，short，int，char)
2.case子句中的值必须是常量，而且所有case子句中的值应是不同的。
3.case通常与break语句联用，以保证多路分支的正确实现，多个case可以公用一组执行语句。
循环语句：1.for循环语句for
2.while循环语句
3.do-while循环语句
4.break和continue语句
break语句，跳出它所在的循环语句或switch 语句，并从紧跟该循环语句或switch 语句后的第一条语句处执行
continue语句，用来结束本次循环，跳过循环体中下面尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环
第四章数据类型，字符串，数组：
1.数据类型：
基本数据类型：
数值型
整数型：
字节型：byte(1个字节)
整型：int(4个字节)
长整型：long (8个字节)
短整型：short(2个字节)
实数型:浮点型：
单精度浮点型：float(4个字节)
双精度浮点型： double(8个字节)}
字符型{char(2个字节)}
布尔型{beloon型(1位)：true 或者 false}
空类型：NULL；
引用数据类型：{数组接口类}：就是将一个堆内存的空间使用权交给了其他对象；
自动类型转换：低优先级数据转换为高优先级数据：
byte-short-char-int-long-float-double
强制类型转换：高优先级数据强制转换为低优先级数据
例：double b=3.2222d；
int a= (int)b；
3.字符串：
==与equals的区别：
在Object类中equals(Object obj)方法与==的比较结果一致的但是equals是一个方法可以被重写，例如在String类中equals比较的就是字符串的内容
String本身是一个类，在String类中定义的构造方法：public String (String original) 可以接收一个String类的对象，并重新实例化String对象，String 还可以采用直接赋值的方式进行对象的实例化
一个字符串是使用“”括起来的那么一个字符串的常量实际上本身就属于String的一个匿名对象
String str = "hello" ; 与 String str = new String("hello"); 有什么区别？、
String str="hello " 如果内存已经为"hello"分配了内存空间，那么Str 只要指向"hello"内存对象地址；
String str = new String("hello"); 内存中重新分配一块内存区域给"hello"，str指向"hello",也就是内存中有两个hello的对象了，而且指向的地址不一样。
String与StringBuffer的区别？
他们都可以存储和操作字符串；
StringBuffer 使用来存储字符串变量，他的对象是可以更改和扩充的，也可以
用来存储字符串常量；
String是用来存储字符串常量，存储的字符串是不可以更改的
字符串的内容一旦声明之后则无法修改，实际上字符串变量的改变改变的是内存空间的地址的指向，而本身的字符内容没有任何的变化。
1.根据字符串中的索引找到指定位置的字符：public char charAt(int
index)
2.将字符串变为字符数组：public char[]toCharArray()
3.将字符数组变为字符串：
将全部的字符数组变为String类型：public String(char[]value)
将部分的字符数组变为String类型：public String（char[]value，int offset，intcount）
4.String- 字节数组：public bute[] gerBytes()
字节数组-String：
全部：public String(byte[]bytes)
部分：public String(byte[]byres,int offset,int length)
5. 判断是否以指定的字符串开头：public Boolean startsWith(String prefix)
判断是否以指定的字符串结尾：public Boolean endsWith(String suffix)
6.替换操作：public String replaceAll(String regex,String replacement)
7.字符串截取：
全部截取：public String substring(int beginIndex)
部分截取：public String substring(int beginIndex.int endIndex)
8.字符串拆分：public String[]split(string regex)
9.字符串查找：
取得指定字符串的位置：public int indexOf(String str),public int indexOf(String str,int fromIndex)此方法返回int型的数据，如果查找到了怎返回位置，查找不到，返回-1
直接查找：public Boolean contains(String s)
10.字符串的其他操作:
去掉左右空格：public String trim()
取得字符串的长度：public int length()
转大写：public String toUpperCase()
转小写：public String toLowerCase()
4.数组:属于引用数据类型，使用时需要开辟内存空间；
数据类型数组名称[]=new 数据类型[长度]；
数据类型数组名称[]=null；
数组名称=new数据类型[长度]；
关键字new只要一出现，怎肯定表示数据类型是是引用数据类型，要进行堆-栈空间的开辟
二维数组：动态初始化：数据类型数组名称[][]=new 数据类型[长度][长度]
静态初始化：
数据类型数组名称[][]={{2,3，2}{2，32,2}}；
char[] 缺省值为0所对应的字符
boolean[]缺省值为false
User[] 自定义类型数组缺省值为null
求数组的长度：
ar.length 属性
二维数组循环打印：
for(int m=0;m for(int n=0;n System.out.print(h[m][n]); } System.out.println(); } 数组拷贝： System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length); src - 源数组。 srcPos - 源数组中的起始位置。 dest - 目标数组。 destPos - 目标数据中的起始位置。 length - 要复制的数组元素的数量 第五章类，方法，关键字保留字： 1.类： 类的基本概念：是用来封装一类对象的状态和方法，类是用来定义对象的模板。是由属性和方法组成；类的属性全部保存在对内存中，全部的方法保存在全局代码中。 抽象类： 包含一个抽象方法的类称为抽象类，抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，所有的抽象类也需要使用abstract 关键字声明，对于抽象类，不能直接进行实例化的操作，但是可以声明，如果要想使用抽象类，则必须依靠子类，抽象类是必须被子类继承的，而且被继承的子类需要实现抽象类中的全部抽象方法； 抽象类中允许有构造方法，但是构造方法是不能直接调用的，是交给子类去调用的，子类对象的实例化过程中永远是先调用父类中的构造方法---实际上来讲抽象类就比普通类多了一个抽象方法而已 抽象类中的属性如果要想初始化，则肯定还是依赖于构造方法 内部类： 作用 1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类，是不允许有private 与protected权限的，但内部类可以 2.内部类拥有外围类的所有元素的访问权限 3.可是实现多重继承 4.可以避免修改接口而实现同一个类中两种同名方法的调用 在一个类的内部还有另外一个类。内部类的缺点：是程序的结构混乱。内部类的唯一优点：在于可以方便访问外部类中的私有成员。如果要在外部类中直接使用内部类的实例化对象 外部类.内部类内部类对象=外部类实例.new 内部类实例（）一个内部类如果使用static关键字声明的话，则此内部类就将成为外部类，可以直接通过外部类.内部类的形式访问 内部类可以在任意地方使用，如在方法中声明方法中定义的内部类可以直接访问外部类的各个成员，但是如果要访问方法中的参数，则参数中要使用final关键字； 普通代码块{ } 构造块：直接在类中定义的代码块( 构造块会重复调用多次；构造块会优先与构造方法执行) 静态块：用static关键字声明的代码块：主要目的是用来为静态属性初始化化。优先于主方法和构造块执行；而且只执行一次； 匿名类： 匿名内部类：在抽象类和接口的基础上发展起来的，在一般的开发中匿名内部类中使用较少，现在只有两种情况下可以经常看到匿名内部类的使用： Java图形界面 Spring开发框架 异常类：Exception 异常与错误： 1.异常是在一个程序执行过程中出现的一个事件，它中断了正常指令的执行 2.偏离了可接受代码的一个动作或实例就是错误 异常结构的分类： Throwable Error Exception 未检查异常(运行时) 已检查异常(编译时) 对异常处理方式-捕获： try{ <可能出现异常的代码块> }catch(Exception e){ <如果try中代码出现异常，则执行catch中的代码> } **注意：catch()代码块可以存在多个，但是catch中的异常类型应该由小到大try{ <可能出现异常的代码块> }catch(Exception e){ <如果try中代码出现异常，则执行catch中的代码> }finally{ <无论有无异常都会被执行的代码块> } **注意：try{}finally{}可以搭配使用 对异常的处理-抛出：throws表明当前函数不处理出现的异常，将异常抛出，交给调用方去处理(处理的方式：捕获、继续抛出) throw关键字，表明被捕获的异常没有经过处理直接抛出 在继承关系中，子类覆盖父类的方法，抛出的异常类型不能比父类更宽泛 所谓异常处理，就是指程序在出现问题时依然可以正确的执行完 异常处理格式：try {可能出现的异常语句} Catch（异常类，异常对象）{异常类，异常对象}{异常处理}..finaly{异常出口} 对于java来讲，当程序出现异常，实际上都是产生了一个类的实例化对象 异常类最大的父类：Throwable Error：一般表示JVM错误，与程序无关 Exception：一般指的是程序的错误，所以一般开发中如果想要进行程序的处理，基本上都是使用此类表示； Class类： 包装类：包装类用于基本数据类型的区别： 1.包装类是对基本数据类型的一种扩展，定义了很多类型之间的转 换方法 2.针对一些集合类型，他们要求我们存入集合的是Object，那么基本数据 类型不能满足要求，就只能放包装类的对象 数值型：Integer,Byte,Short ,Float,Double,Long都是Nummber的子类其他类型：Character，Boolean---Object子类； 装箱操作：Integer i=new Integer(i); 拆箱操作：int j=i.intValue(); jDk 1.5之后增加了很多新特性如：foreach 可变参数，即自动装箱拆箱操作； Integet i=I; 自动装箱操作 int j=i; 自动拆箱操作 Object类： 如果一个类中没有明确指定继承那个父类，则默认情况下就是继承Object 类；任何类的对象都可以使用object进行接收，不光可以接收类的引用，只要是引用数据类型都可以使用object类接收 对于一个完整的类来讲，应该覆写Object类中的以下三个方法： toString ：对象打印时调用public String toString（） equals（）：对象比较时调用，实际上String类就已经覆写好了此方法 public Boolean equals（object obj） hasCode() 暂时不看 Object可以接收任意的应用数据类型的引用 2.方法：就是一段可以重复调用的代码段；一个方法可以接受一个数组或者返 回一个数组，但是在接受数组的时候一定要注意，数组是引用数据类型，所以方法中对数组所做的一切修改最终都会被保留下来； 方法调用过程： 1.为被调用方法分配临时存储空间 2.将实参复制一份传给形参 3.跳入被调用方法中执行 4.方法体执行完成或遇到return语句，返回主方法，同时被调用方法的 临时存储空间被收回 抽象方法： 构造方法：一个用来初始化对象的一个方法，在每个类中都存在一个构造方法。构造方法的主要目的是为类中属性初始化；所有的构造方法应该是对象操作前最早调用的；如果一个类中没有明确声明一个构造方法，则会自动生成一个无参的什么都不做的构造方法；当使用关键字new时才会调用类中的构造方法； 要求：构造方法名称与类名称一致 构造方法定义没有返回值类型的声明 不能在构造方法中使用return返回一个内容 用new +构造方法来创建一个新的对象 构造方法私有化-单例设计，一个类只能产生一个实例化对象；实现的核心：一个类中必须有构造方法，如果将构造方法私有化之后，那么外部无法产生新的实例化对象了； 重载：指的是方法名称相同，但是参数的类型和个数不同 方法名相同，参数列表不同 参数列表：1.参数类型 2.参数个数 系统会根据调用时传递的参数自动找到匹配的同名方法进行调用 覆写：发生在继承的关系中，子类覆写了父类中的相关方法，子类定义了与 父类同名的方法，成为方法的覆写；在方法覆写时候注意：被覆写的方法不 能拥有比子类更加严格的访问权限；访问权限 private 在使用子类实例化对象调用类中被覆写过的方法时，调用的永远是被覆写 过的操作，永远不是覆写，而是从新定义； 如果希望调用父类中被子类覆写过的方法，则只能通过super方法（）形式 调用； 属性的覆盖，子类中声明了父类中同名的方法成为覆盖，但从实际的开发 来讲，属性基本上属于private类型，所以覆盖这种概念根本不存在 调用 在使用递归操作的时候一定要注意递归操作要有明确的截止条件，否则会 出现异常； 3.关键字关键字列表： abstract boolean break byte case catch char class continue default do double else extends enum false final finally float for if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient true try void volatile while Java 中 true false 不是关键字,而是boolean类型的字面量 所有的关键字都是小写，friendly，sizeof不是java的关键字 Super： 1.调用父类的方法或属性，前提是方法和属性在子类中是可见的 2.super()调用父类中的无参构造 3.在调用父类构造方法的时候必须放在第一句 Abstract：abstract类： 1.如果一个方法没有方法体，那么该方法一定为abstract方法 2.如果一个类中有一个abstract的方法，那么该类一定为abstract 类 3.abstract类不能被实例化 Abstract a = new MyClass();//MyClass extends Abstract Final： 声明类：声明的类不能有子类 声明方法：声明的方法不能被子类覆写 声明变量：声明的变量就称为常量，常量是不可以修改的 在java中如果使用final声明一个常量的话，怎常量的标示符必须全部大写使用public static final 声明的常量称为全局常量 This： 可以表示当前对象；通过this.属性表示当前类中的属性；通过this.方法（）表示当前类的方法；通过this（）可以调用本类中的其他构造方法，但是要求至少有一个构造方法中没有使用this（），而此构造方法将作为调用的出口，一般这个出口都会使用无参构造完成；而且调用时this（）要放在构造方法的首行 Static：1.修饰变量，变量被所有实例所共享 2.修饰方法，方法内不可以引用非静态成员；但是非静态方法可以引用静态 成员 使用static关键字可以声明全局变量，所有对象共同拥有 Static属性或方法可以直接通过类名称调用 Static方法只能调用static属性方法，而不能调用非static的属性或方法静态属性和方法可以在没有实例化对象的时候调用。使用static可以统计一个类产生了多少个实例化对象，因为static的属性是所有对象共享的； 在开发中还可以使用static进行自动命名操作； Throws：在程序中的方法声明处可以使用throws关键字，使用此关键字的最大好处是：在方法中不处理任何的异常，而是交给调用处处理； 在程序中可以使用throw关键字人为的抛出一个异常，在异常的处理中，实际上每次产生异常的时候都产生了一个异常类的实例化对象，那么此时也可以通过抛出异常对象的方式完成 异常处理的其他操作；NumberFormatException 是RuntimeException 的子类那么也就是说只要是RuntimeException的异常对象虽然使用了throws 但是在程序中也可以不使用 try…catch 进行处理 一个类只要继承了Exception则就表示一个自定义的异常，当发现系统中提供的异常类不够时就可以这样做； assert：表示断言，就是表示说当程序执行到某条语句之后，其结果肯定是固定值； 4.保留字：asser enum const goto 第六章对象，继承，接口, 包： 1．对象：声明对象：类名对象名称=null； 实例化对象：对象名称=new 类名（）； 类名对象名称=new 类名（）； 访问属性：对象名称.属性名 访问方法：对象名称.方法名（） 匿名对象：在一个对象被创建之后，调用对象的方法是可以不定义对象的引用变量，直接调用该对象的方法；只是用一次的对象； 2．继承：可以复用代码，缩短开发周期，节约成本 就是扩展已有类的功能，在继承中分为子类和父类；父类有时候又称为 超类，子类有时候成为派生类；extends 继承类限制：在使用继承类的时候虽然可以扩充类的功能，但是其本身也存在以下限制：在java中不允许多重继承：一个子类只能继承一个父类，不能继承多个父类； 在java中允许多层继承，在继承中子类不能访问父类中的私有操作，而 只能继承全部的公有操作，对于私有内容不能直接访问，但是可以通过 其他途径访问 在实例化子类对象时候肯定要先实例化父类中的内容，为父类初始化， 那么实际，此时对于子类的构造方法而言，实际上就隐藏了一个super（）语句---表示父类的无参构造； 子类对象的实例化过程：先去调用父类中的构造方法，之后再执行子类 自己的构造方法，父类的构造方法执行完之后实际上是为父类中的属性 初始化了，但是未执行完的话，子类的构造方法就永远不能调用，那么 子类的所有属性都无法初始化，那么默认值为0 一个子类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口，这个原则必须始终记住； 如果想要进行向下转型，则首先必须产生向上转型的关系 3．接口 1.接口是一个特殊的抽象类 2.接口中的方法都是public 的抽象方法 3.一个类可以实现多个接口 InterfaceTest implements MyInterfaceA,MyInterfaceB 4.接口中的所有属性都会自动声明为final static final static int a = 10; public abstract void showA(); 接口是一个特殊的类，在java中接口是抽象方法和全局常量组成的，在java中使用interface来定义一个接口 实现接口通过implements关键字来完成 一个类虽然只能继承一个父类，但是一个类可以实现多个接口，使用接 口完成多继承的功能，一个类既要实现接口又要继承抽象类的话，则必 须按照以下形式： Class子类extends抽象类implement是接口A，接口B,…..{} 一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类，一个接口虽然不可以继承一个抽象类，但是一个接口却可以同时继承多个接口； 接口也可以像抽象类那样通过对象的多态性进行对像的实例化操作； 正常情况下一个接口的之类要实现全部的抽象方法； 4．包：就是一个文件夹，不同的文件件中可以存在同名的类在java中使用package语法定义包； 通过javac –d ./ Hello.java 命令进行打包编译； d：表示生成目录；根据package的定义生成 . ：表示在当前所在的文件夹中生成 导入包在程序中很多类都存放在不同的包中，使用import语句进行导包操作时，如果一个包中的类需要被外部所访问，那么此类一定声明public class；类型 静态导入：如果一个包中某个类中的方法全部都是static类型则就可以使用静态导入； 系统用包： Java. Lang.此包中包含了各种常用的类，此包属于自动导入，但是在JDK 1.0 时此包必须手工导入； https://www.360docs.net/doc/d715478452.html,ng.reffect:此包属于反射机制包，是整个java中最重要的包，此包完成大量的低层操作 Java.util包：工具包，如果把此包掌握非常清楚，则可以方便做各种开发，做各种设计 Java.IO包：IO操作 https://www.360docs.net/doc/d715478452.html,：网络编程 Java。Sql:数据库编程： Java.text：国际化程序运用 史上最全Java基础知识点归纳 写这篇文章的目的是想总结一下自己这么多年来使用Java的一些心得体会，主要是和一些Java基础知识点相关的，所以也希望能分享给刚刚入门的Java 程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。 这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE 相关的、和Java中各个框架相关的内容。 经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。 1.JVM相关(包括了各个版本的特性) 对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资 深开发者来说，不会JVM几乎是不可接受的。 JVM作为Java运行的基础，很难相信对于JVM一点都不了解的人可以把Java语言吃得很透。我在面试有超过3年Java经验的开发者的时候，JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证Java开发能力的高低。 在JVM这个大类中，我认为需要掌握的知识有： JVM内存模型和结构 GC原理，性能调优 调优：Thread Dump，分析内存结构 class二进制字节码结构，class loader体系，class加载过程，实例创建过程 方法执行过程 Java各个大版本更新提供的新特性(需要简单了解) 2.Java的运行（基础必备） 这条可能出看很简单，Java程序的运行谁不会呢？不过很多时候，我们只是单纯通过IDE去执行Java程序，底层IDE又是如何执行Java程序呢？很多人并不了解。 https://www.360docs.net/doc/d715478452.html,ng.Object 类，是所有类的根父类！ 2.Object类仅有一个空参的构造器public Object(){ } 3.关于方法： ①equals(Object obj) public boolean equals(Object obj) { return (this == obj); } // == // 1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，反之返回false // 注：两端数据类型可以不同，在不同的情况下，也可以返回true。 // 2.引用数据类型：比较引用类型变量的地址值是否相等。 //equals(): >①只能处理引用类型变量②在Object类，发现equals()仍然比较的两个引用变量的地址值是否相等 >像String 包装类File类Date类这些重写Object类的equals()方法，比较是两个对象的 //"实体内容"是否完全相同。 >若我们自定义一个类，希望比较两个对象的属性值都相同的情况下返回true的话，就需要重写Object类的 equals(Object obj)方法 ②toString()方法 当我们输出一个对象的引用时，会调用toString()方法。 1.public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } 当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置 2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。 3.像String类、Date、File类、包装类都重写了toString()方法。 1. String类：不可变的字符序列（如：String str = "atguigu"; str += "javaEE"） 1.关注于String常用的方法！ 2.String类与基本数据类型、包装类；与字符数组、字节数组； * 1.字符串与基本数据类型、包装类之间转换 * ①字符串--->基本数据类型、包装类:调用相应的包装类的parseXxx(String str); * ①基本数据类型、包装类--->字符串:调用字符串的重载的valueOf()方法 * Created by AIwen on 2017/5/14. java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。 java也支持面向对象的三大特征：封装、继承、和多态。java提供了private、protected、和public三个访问控制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的成员变量和和方法，如果访问控制允许，子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。 面向对象的程序设计过程中有两个重要的概念：类（Class)和对象（object，也被称为实例，instance）。类可以包含三种最常见的成员：构造器、成员变量、和方法。 构造器用于构造该类的实例，java语言通过new关键字类调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常无法创建实例。因此java语言提供了一个功能：如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器，这个构造器总是没有参数的。一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器。 构造器用于对类实例进行初始化操作，构造器支持重载，如果多个重载的构造器里包含了相同的初始化代码，则可以把这些初始化代码放置在普通初始化块里完成，初始化块总在构造器执行之前被调用。静态初始化块代码用于初始化类，在类初始化阶段被执行。如果继承树里某一个类需要被初始化时，系统将会同时初始化该类的所有父类。 构造器修饰符：可以是public、protected、private其中之一，或者省略构造器名：构造器名必须和类名相同。 注意：构造器既不能定义返回值类型，也不能使用void声明构造器没有返回值。如果为构造器定义了返回值类型，或使用void声明构造器没有返回值，编译时不会出错，但java会把这个所谓的构造器当成方法来处理——它就不再是构造器。 实际上类的构造器是有返回值的，当使用new关键字来调用构造器时，构造器返回该类的实例，可以把这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类，无须定义返回值类型。不要在构造器里显式的使用return来返回当前类的对象，因为构造器的返回值是隐式的。 java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 成员变量： 成员变量的修饰符：public、protected、private、static、final前三个只能出现一个再和后面的修饰符组合起来修饰成员变量，也可省略。 成员变量：由一个或者多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 类型：可以是java语言允许的任何数据类型，包括基本类型和引用类型。 成员方法： 方法修饰符：public、protected、private、static、final、abstract，前三个只能出现一个，static和final最多只能出现其中的一个，和abstract组合起来使用。也可省略。 返回值类型：可以是java语言的允许的任何数据类型，包括基本类型和引用类型。 方法名：和成员变量的方法命名规则相同，通常建议方法名以英文动词开头。 方法体里多条可执行语句之间有严格的执行顺序，排在方法体前面的语句总先执行，排在方法体后面的语句总是后执行。 static是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static修饰的成员表明它属于这个类本身，而 目录 第一章 Java入门 (2) 第二章 Java基础 (5) 第三章条件转移 (16) 第四章循环语句 (22) 第五章方法 (28) 第六章数组 (35) 第七章面向对象 (44) 第八章异常 (65) 第一章Java入门 知识点汇总 1、JAVA 三大体系 ?Java SE：（J2SE，Java2 Platform Standard Edition，标准版），三个平台中最核心 的部分，包含Java最核心的类库。 ?JavaEE：（J2EE，Java 2 Platform, Enterprise Edition，企业版），开发、装 配、部署企业级应用，包含Servlet、JSP、 JavaBean、JDBC、EJB、Web Service等。 ?Java ME：（J2ME，Java 2 Platform Micro Edition，微型版），用于小型电子设备 上的软件开发。 2、JDK,JRE,JVM的作用及关系 作用 ★JVM：保证Java语言跨平台 ★JRE：Java程序的运行环境 ★JDK：Java程序的开发环境 关系 ★JDK：JRE+工具 ★JRE：JVM+类库 3、JDK环境变量配置 ?path环境变量：存放可执行文件的存 放路径，路径之间用逗号隔开 ?classpath环境变量：类的运行路径， JVM在运行时通过classpath加载需要 的类 4、重点掌握两个程序 ?javac.exe：Java编译器工具，可以将编 写好的Java文件（.java）编译成Java 字节码文件（.class）; ?java.exe：Java运行工具，启动Java虚 拟机进程，运行编译器生成的字节码 文件(.class) 5、一切程序运行的入口 public static void main（String args []）{ System.out.println(“Hello World!”); } 课堂笔记 j a v a面向对象知识点总 结 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998 1 类和对象 类: 类是用来描述一类事物的共性内容的, 类是抽象的; 创建类,如何描述 属性功能 用变量来描述属性 用方法来描述功能 对象: 就是现实中具体的事物,对象是具体的; 创建对象 类名对象名 = new 类名(); 如何通过对象访问类中属性和方法呢 对象名.变量名 对象名.方法名(); 只要是new的对象,就是新创建的,就会在内存中开辟一段单独的空间匿名对象 创建的对象没有赋值给具体的变量; 所以给匿名对象的属性赋值是没有任何意义的; 匿名对象使用场景 1 调用方法 2 作为参数传递 3 添加进容器中 This 关键字 This. 类中的普通方法访问到的成员前边都有this.这个关键字This. 就代表当前对象, 普通方法, 创建对象调方法, 谁调用就代表谁 This(); 可以用来在构造函数中调用本类与之相对应的构造函数使用注意事项: 1 this() 只能是构造函数的第一条执行语句 2 this() 不能在构造函数之间相互调用 3 this() 不能调用自己 构造函数(方法) 构造函数的作用 用来给对象进行初始话的(初始化就是指给对象的各个属性赋值) 构造函数何时执行 对象一创建就会调用与之相对应的构造函数 构造函数语法 修饰符没有返回值类型类名(参数列表){ 具体执行的代码 } 构造函数自动添加 当一个类中我们没有明确指定构造函数的话,jvm会自动帮我们添加一个空参数的构造, 如果我们指定了,就不添加了 构造函数和普通函数的区别 执行时机不同 对象一创建就会调用与之相对应的构造函数 普通函数只有被调用才会执行 return 1 就是用来在方法中返回具体结果(结果类型必须和方法的返回值类型一致) 2 即便方法的返回值类型是void,方法中也可以出现 return; 3 构造函数中也可以有return关键字 成员变量和局部变量 1 作用范围不同, 成员变量是定义在类中的,在整个类中都起作用 局部变量是定义在方法中的,在所在代码块起作用 一、单选题 1.对类：(B) public class Test( //...do something } 下面那个正确地定义了类Test的构造函数。 A)public void Test() () B)publicTest()(} C ) public static Test() (} D) publicTest(); 2.下面哪个函数是public void example()(...)的重载函数。(A) A)public void example( float f)(...) B)public int example() (...) C)public void example2()(...} D)public int example_overLoad ()(...) 3.下面的代码段中，执行之后i和j的值是_C_。 int i = 1; intj； j = i++； A)1, 1 B) 1,2 C) 2, 1 D) 2,2 4.以下for循环的执行次数是_B o for(int x=0,y=0;(y !=0)&&(x<4) ;x++); A)无限次B) 一次也不执行 C)执行4次D)执行3次 5.下面程序的输出结果是—C o public class People( String name; int id; public People( String str, int n )( name = str; id = n; } public String toString(){ return id + " ：” + name; } public String print()( 目录 第一章Jaｖa入门2? 第二章 Java基础5? 第三章条件转移1?４ 第四章循环语句20? 第五章方法 ............................................... ２6 第六章数组33? 第七章面向对象........................................... 4２第八章异常63? ? 第一章Jaｖａ入门 知识点汇总 1、JAVA 三大体系 ?Jａva ＳE：（J2SE，Jａva2 Plａtｆｏrm Ｓｔandaｒd Edｉtion,标准版），三个 平台中最核心的部分，包含Jaｖa最核 心的类库。?JａvaEＥ:(J2EＥ，Jａva 2 Platfｏｒｍ, EｎteｒpｒisｅEditiｏｎ，企业版）, 开发、装配、部署企业级应用，包含 Servlet、ＪSP、ＪａｖａＢeａn、ＪDB Ｃ、ＥJＢ、Web Ｓerｖice等。 ?Java ＭE:（J2ＭE,Jａva 2 Pｌaｔfｏr ｍMicｒo Ediｔiｏn，微型版），用于 小型电子设备上的软件开发。 2、JDK，JRＥ,JＶＭ的作用及关系 作用 ★JVM：保证Jaｖａ语言跨平台 ★JRＥ：Javａ程序的运行环境 ★ＪＤK:Jaｖa程序的开发环境 关系 ★JDK:JRE+工具 ★JRE:ＪＶM+类库 3、ＪDＫ环境变量配置 ?pａtｈ环境变量:存放可执行文件的存 放路径,路径之间用逗号隔开 ?classpａth环境变量：类的运行路径,J ＶＭ在运行时通过cｌasspａth加载需 要的类 4、重点掌握两个程序 ?javac．eｘe:Java编译器工具，可以将 编写好的Ｊava文件（．jａva）编译成 Ｊava字节码文件（．cｌaｓs）； ?javａ.ｅxe:Jaｖa运行工具，启动Jaｖa 虚拟机进程，运行编译器生成的字节 码文件(．ｃlass） 5、一切程序运行的入口 puｂｌｉｃstaｔic vｏiｄmain(Strｉng aｒgs []）｛ Syｓtem．out.ｐriｎtｌｎ（“Hel ｌo Ｗorld!”）； } 课堂笔记 练习题 一、填空题 1、Java的三个技术平台分别是（J2SE )、（Ｊ2EE)、(J2ME）。 2、Sun公司针对领域不同，提供了三个Jaｖa版本,其中对于个人计算机程序开发的是( Ｊ2SE ), 对于企业开发应用的是（J2EE)，对于嵌入式设备应用开发的是( J２ＭＥ )。 （ｃｌasｓｐａth )。 3、建立Java开发环境，安装ＪＤK,一般需要设置环境变量（path）、 4、编写一个Jａva源程序,其文件名为Teｓt．java，则编译该源程序的命令为（javac )，运行 该程序的命令为( java），生成文档注释的命令为( javadoc)。 5、Java程序的运行环境简称之为( JRE)。 Java基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java 的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java 运行的所需的类库+JVM(java虚拟机)。 3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。 classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； java知识点总结 应同学要求，特意写了一个知识点总结，因比较匆忙，可能归纳不是很准确，重点是面向对象的部分。 java有三个版本：JAVA SE 标准版\JAVA ME移动版\JAVA EE企业版 java常用命令：java, javac, appletview java程序文件名：.java, .class java的两类程序：applet, application; 特点，区别，这两类程序如何运行 java的主方法，主类，共有类；其特征 java的数据类型，注意与C++的不同，如字符型，引用型，初值 java与C++的不同之处，期中已总结 java标记符的命名规则 1）标识符有大小写字母、下划线、数字和$符号组成。 2）开头可以是大小写字母，下划线，和$符号（不能用数字开头） 3）标识符长度没有限制 4）标识符不能使关键字和保留字 面向对象的四大特征 抽象、封装、继承、多态 封装，类、对象，类与对象的关系，创建对象，对象实例变量 构造函数，默认构造函数，派生类的构造函数，构造函数的作用，初始化的顺序，构造方法的重载 构造函数：创建对象的同时将调用这个对象的构造函数完成对象的初始化工作。把若干个赋初值语句组合成一个方法在创建对象时一次性同时执行，这个方法就是构造函数。是与类同名的方法，创建对象的语句用new算符开辟了新建对象的内存空间之后，将调用构造函数初始化这个新建对象。 构造函数是类的特殊方法： 构造函数的方法名与类名相同。 构造函数没有返回类型。 构造函数的主要作用是完成对类对象的初始化工作。 构造函数一般不能由编程人员显式地直接调用。 在创建一个类的新对象的同时，系统会自动调用该类的构造函数为新对象初始化。 类的修饰符：public类VS 默认; abstract类; final类; 1）类的访问控制符只有一个：public，即公共的。公共类表明它可以被所有其他类访问和引用。 若一个类没有访问控制符，说明它有默认访问控制特性，规定该类智能被同一个包中的类访问引用（包访问控制）。 2）abstract类：用abstract修饰符修饰的类被称为抽象类，抽象类是没有具体对象的概念类，抽象类是它所有子类的公共属性集合，用抽象类可以充分利用这些公共属性来提高开发和维护效率。 3）final类：被final修饰符修饰限定的，说明这个类不能再有子类。所以abstract与final 不能同时修饰一个类。 域和方法的定义 1)域：定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据。 复习题2 如有雷同，纯属巧合！ 1.下列哪一种叙述是正确的() A. abstract修饰符可修饰字段、方法和类 B.抽象方法的body部分必须用一对大括号{ }包住 C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 2.下列说法正确的有() A. class中的constructor不可省略 B. constructor必须与class同名，但方法不能与class同名 C. constructor在一个对象被new时执行 D.一个class只能定义一个constructor 3.以下哪个表达式是不合法的（） A、String x=”Hello”; int y=9; x+=y; B、String x=”Hello”; int y=9; if(x= =y) { } C、String x=”Hello”; int y=9; x=x+y; D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length() : 0 4.下列关于修饰符混用的说法，错误的是（） A．abstract不能与final并列修饰同一个类 B．abstract类中不可以有private的成员 C．abstract方法必须在abstract类中 D．static方法中能处理非static的属性 5.（）修饰符允许对类成员的访问不依赖于该类的任何对象 A、abstract B、static C、return D、public 6.关于被私有访问控制符private修饰的成员变量，以下说法正确的是（） A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类 B．可以被两种类访问和引用：该类本身、该类的所有子类 C．只能被该类自身所访问和修改 D．只能被同一个包中的类访问 基础 1.object类的方法有哪些 clone() protect 创建并返回一个对象的副本 equals()用来比较某个对象是否与调用此方法的对象相等 finalize() protect getClass() 返回一个对象的运行时类 hashCode()返回一个对象的hash值 notify()唤醒在此对象监听器上等待的单个线程。如果有多个，则随机唤醒一个 notifyAll()唤醒在此对象监听器上等待的所有线程 registerNatives() 本地私有方法，在类初始化是会调用此方法 toString() 返回当前对象的字符串表示 wait()使当前线程处于等待直到其他线程调用这个对象的notify或notifyAll方法或者超过指定的时间量 2.接口和抽象类的区别 1.首先描述接口和抽象类的特性 抽象类：是子类通用特性的集合 接口:是抽象方法的集合l 从某种意义上说抽象类包含了接口的所有功能。但是通过实现接口可以实现多继承 什么时候用抽象类和接口 1.如果一些方法必须提供默认的实现，就必须用抽象类，比如在dao层，每个类都有增删查改这几个操作，我们可以把这些操作写在抽象类里，并让抽象类提供默认的实现。 否则的话用接口 2.假如要实现多继承，则必须要用接口,java不支持多继承但是可以通过实现多个接口来解决 3.如果基本功能在不断改变，那么就用抽象类。如果不断改变基本功能并且使用接口，子类就必须不停的更改 03.抽象类是否有构造方法 抽象类有构造方法只是抽象类不能够实例化 4.Final finally finalize()方法的区别 5.Sleep()和wait()的区别 ①这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。 ②锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS 分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。 Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。 ③使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，配合synchronized实现等待通信机制，而sleep可以在任何地方使用。 synchronized(x){ x.notify() //或者wait() } javaweb知识点总结 篇一：javaweb期末复习知识点整理 1、 Web应用概述 1. URL与URI URL: 统一资源定位器 URI：统一资源定位符 2. 常见HTML标签 3. 表单的处理 4. 静态文档与动态文档的概念：静态文档是一种以文件的形式存放在服务器端的文档，客户发出对该文档的请求，服务器返回这个文档。动态文档是指文档的内容可根据需要动态生成，又可分为服务器端动态文档和客户端动态文档技术。 5. Servlet概念：服务器端小程序，是使用ServletAPI 以及相关类编写的java程序，主要用来扩展web服务器的功能。 6. 处理404错误：查看给定的路径名是否正确，查看Servlet类文件是否在classes目录下，查看文件内容是否正确，查看tomcat是否启动 2、 Servlet技术模型 1. Servlet的API：包，包 Servlet接口及方法 : 1） public void init(ServletConfig config)：完成Servlet初始化并准备提供服务。容器传给该方法一个ServletConfig类型的参数。 2）public void service(ServletRequest req,ServletResponse res)throw ServletException,IOException：对每个客户请求容器调用一次该方法，它允许Servlet为请求提供响应。 3） public void destroy()该方法由容器调用，指示Servlet清除本身，释放请求的资源并准备结束服务。 4） public ServletConfig getServletConfig()返回关于Servlet的配置信息，如传递给init()方法的参数。 5） public String getServletInfo()返回关于Servlet 的信息，如作者，版本及版权信息。 ServleConfig接口作用及方法 HttpServlet类 :新的service方法，doGet，doPost HttpServletRequest接口及常用方法 HttpServletResponse接口及常用方法 2. Servlet的开发步骤 编写一个Servlet类 编译 部署 (1)在tomcat的虚拟目录下，创建Web目录 Java基础测试题 一、选择题（每题2分） 1、在JAVA编程中，Java编译器会将java程序转换为（）。 A. 字节码； B. 可执行代码； C. 机器代码； D. 以上所有选项都不正确。 2、下列那些不是合法的标识符？（） A. Tel_num B. 8ABc C. Emp_1 D. b123.6 E. NULL F. Hello World 3、以下字符常量中不合法的是( )。 A. '|' B. '\'' C."\n" D.'我' 4、下列语句编译没有错误的是：（） A. float a=1.5; B.byte a=129; C.byte a=5; D.byte a=(byte)200; 5、java中int数据类型在内存中表示为（） A. 2个字节 B.4个字节 C. 由程序员指定 D. 以上都不正确 6、下列程序段执行后t5的结果是( )。 int t1 = 9, t2 = 11, t3=8; int t4,t5; t4 = t1 > t2 ? t1 : t2+ t1; t5 = t4 > t3 ? t4 : t3; A. 8 B.20 C.11 D.9 7、若有定义int a = 2;则执行完语句a += a -= a * a; 后，a的值是( )。 A. 0 B. 4 C. 8 D.–4 8、设 a, b, c, d 均为 int 型的变量，并已赋值，下列表达式的结果属于非逻辑值的是( ) A. a!=b & c%d < a B.a++ = =a+b+c+d C.++a*b--+d D.a+b>=c+d 9、以下代码段执行后的输出结果为（） int x=3； int y=10； System.out.println(y%x); A.0 B.1 C.2 D.3 10、下列语句序列执行后，k 的值是( )。 int i=10, j=18, k=30; switch( j - i ) { case 8 : k++; case 9 : k+=2; case 10: k+=3; default : k/=j; } A. 31 B. 32 C. 2 D.33 11、假定有变量定义: int k=7,x=12; 则能使值为3的表达式是（）。 A. x%=(k%=5) B.x%=(k-k%5) C. x%=k-k%5 D. (x%=k)-(k%=5) 12、设x和y均为int型变量,则以下语句:x+=y；y=x-y；x-=y；的功能是（）。 A. 把x和y按从大到小排列 B. 把x和y按从小到大排列 Java期末知识点整理总结 计科2班苏锐师编号47 学号201330551464 第一章 Java语言概述 1. Java语言发展历史和现状及前景 2. Java语言的特点： 简单、面向对象、分布式、健壮性、结构中立、 安全性、可移植、解释的、高性能、多线程、多态性 3. Java虚拟机概念（JVM），Java程序的执行过程 4. Java应用程序分类：Application和Applet 5. Java程序的开发环境：JDK，IDE 第二章 Java数据类型及其运算 1. 标识符与保留字 1.2 标识符命名语法规则与Java推荐的标识符命名规则 1.3 Java中的关键字 2. 数据类型byte, short, int long, char, float, double, boolean 注意点：Java中所有数据类型是确定的，与平台无关，没有sizeof操作，其中特别注意char 类型是2字节Unicode编码，与C++ 不同；知道基本类型都有对应的默认值。 整型数的十进制、八进制、十六进制值的表示。 实型数的十进制、十六进制与科学计数法表示，注意实型常量默认类型为double型。 3. 运算符与表达式算术运算符： + - * / % ++ -- 关系运算符：> >= < <= == != 逻辑运算符：&& || ！& | 注意短路计算与非短路计算的差别 位运算符： >> << >>> & | ^ ~ 要认识异或(^)与按位取反(~)运算符 赋值运算符： += -= *= /= %= &= |= ^= <<= >>= >>>= 要注意赋值运算符中包含了强制转换： 若： int k = 1; k += 44.232D; 则相当于： k = (int) ( k + 44.232D); 条件运算符：exp ？stat1 ：stat2 要注意stat1与stat2要求类型相兼容且不能为void类型。运算符的优先级：算术运算 > 关系运算> 逻辑运算 JSE第一部分 分享者：张振羽 2017.6.30 1.什么是 JDK API (1) Application Programming Interface ,应用程序编程接口 (2) 是一些预先定义的函数，开发人员可提供直接调用的功能。 2.JDK包结构 便于维护，按照功能划分，不同功能的累划分在不同功能的包中，常用的包如下表： 3.字符串的基本操作 3.1 String 及其API 3.1.1 String (1) String是不可变对象 (2) https://www.360docs.net/doc/d715478452.html,ng.String使用了final修饰，不能被继承。 (3)字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中 (4) 任何一个字符对应2个字节的长度，1个字节 = 8位二进制。 3.1.2 String s=new String (“abc”) (1) 众所周知，答案是:创建两个对象 (2) why?举例子： 分析步骤： a) 栈中开辟一块空间存放引用str1（地址信息）； b) String池中有一块空间，存放String常量"abc"； c) 引用str1指向池中String常量"abc"； d) str1所指代的地址即常量"abc"所在地址，输出为true； 结论：创建了一个引用对象str1 分析步骤： 1) 栈中开辟一块空间存放引用str3； 2) 堆中开辟一块空间存放一个新建的String对象"abc"； 3) 引用str3指向堆中的新建的String对象"abc"； 4) str3所指代的对象地址为堆中地址，而常量"abc"地址在池中，输出false； 3.2 StringBuilder常见API Java知识点总结 1环境搭建与开发 1.1 环境变量 JA V A_HOME：Java的安装目录； CLASSPATH：指定一个路径列表，用于搜索Java在编译或运行时需要用到的类（.class文件）； PATH：指定一个路径列表，用于搜索可执行文件。 1.2 Java SDK应用 编译：Javac 类名.class； 运行：Java 类名； 打包：jar cf test.jar test （把当前目录下的test目录下的所有文件压缩到test.jar文件中）。 2变量与常量 Java中的常量用保留字final来实现。 变量：局部变量（local variable）、实例变量（instance variable）、类变量（class variable）；任何变量在使用前都必须初始化，局部变量必须显示初始化，实例变量在类的构造方法被调用时初始化（分配默认值），类变量在类被加载时被初始化。 3标识符 3.1 命名 在Java语言中，标识符的定义规则是以字母、下划线、美元符开始，后面可以跟字母、下划线、美元符、数字。 因为Java语言使用Unicode字符集，所以对字母不仅限于英文，还可以是日文、韩文、阿拉伯文、中文等。 区分大小写，没有字数限制。 3.2 关键字 3.2.1static static方法中不能有this和super关键字（static方法不是“面向对象”的，而是“面向类”的）。 static方法中只能访问所属类的static方法和变量。 static数据成员的初始化：在第一次生成该类的对象时初始化。 3.2.2final 1)final数据 a)static final ●更加典型的定义方式是public static final； ●占用一段不能改变的存储空间； ●代表编译时常量，即在编译器就能知道其值（如果只声明为final或 者static，是在运行时才知道值）。 ●全部用大写字母命名，单词之间用下划线隔开。 b)final数据与final引用 ●final数据的值不能被改变； ●final引用是指无法将其指向一个新的对象（数组也是一种引用），对 象本身的值是可以改变的。 c)空白final（声明为final却未赋初始值） ●可以做到根据对象有所不同，又保持恒定不变的特性； ●必须保证使用前已经初始化：在定义处赋值或者在构造器中赋值。 2)final参数 ●无法在方法中更改引用所指向的对象。 3)final方法 ●禁止覆盖，防止任何继承类修改它的定义； ●private方法都是final的，因此private方法无法覆盖。 4)final类 ●不允许继承该类； ●final类中的所有方法都隐式指定为final的。 基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。 4，该技术什么时候用？。 一：概述： 1991 年公司的等人开始开发名称为的语言，希望用于控制嵌入在有线电视交换盒、等的微处理器； 1994年将语言更名为； 的三种技术架构: ：，开发企业环境下的应用程序，主要针对程序开发； ：，完成桌面应用程序的开发，是其它两者的基础； ：，开发电子消费产品和嵌入式设备，如手机中的程序； 1，：，的开发和运行环境，的开发工具和。 2，：，程序的运行环境，运行的所需的类库(虚拟机)。 3，配置环境变量：让\目录下的工具，可以在任意目录下运行，原因是，将该工具 所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：安装路径%\\ \ 2）：临时配置方式：:\ \\\ 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去中设置的路径下找。 的配置: 1）：永久配置方式：:\:\ 2）：临时配置方式：:\:\ 注意：在定义环境变量时，需要注意的情况 如果没有定义环境变量，启动后，会在当前目录下查找要运行的类文件； 如果指定了，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。 一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，命令和命令做什么事情呢？ 要知道是分两部分的：一个是编译，一个是运行。 ：负责的是编译的部分，当执行时，会启动的编译器程序。对指定扩展名的文件进 JAVA知识点总结 1．JAVA的特点： ○1简单易用、完全面向对象； ○2与平台无关性、可扩展性强； ○3可移植性高、支持分布式编程； ○4健壮、安全可靠并性能优异； ○5支持多线程开发技术； ○6支持动态开发。 2.JVM：Java虚拟机（JVM是Java实现跨平台的基础）。 Java的源程序（*.java）编译（命令：java+文件名.java）Java字节码（*.class编译时自动形成，与源程序名一致) 运行（命令：java+源程序的文件名）JVM（Windows、Linux) 开发工具，Javac及基础核心类 JDK 运行环境，Java及基础核心类 3.编写第一个Java程序： Java源文件扩展名为：”.java” 一个源文件中最好只有一个java类，但是可以包含多个类 public修饰的类，文件名与类名必须一致(包括大小写) 被运行的类中需要有一个方法： public static void main(String[ ] args){} 一个源文件中最多有一个public修饰的类 例如：public class Test{ public static void main(String args[]){ System.out.println(“这个编写的第一个java程序！！！”); } } 在运行程序之前先配置环境变量： path变量值为：JDK安装目录下\bin; classpath变量值为：JDK安装目录下\lib; 或 .;JDK安装目录下\lib\tools.jar 在dos命令窗口中输入以下命令进行运行： 编译命令：javac Test.java 运行命令：java Test 生成文档命令：javadoc Test.java 4.Java编程规范 A、命名规定 包：包名应该是小写的名词。 如：package shipping.objects 类：类名应该是名词，大小写混合，每个单词的首字母大写。 如：class AccountBook 接口：接口名的大小写应该与类名一样。 如：interface Account 方法：方法名应该动词，大小写混合，首字母小写。每个方法名中，以大写字母区分单词。限制使用下划线。 第1章 Java概述 Java语言的特特点 一种面向对象的语言；一种平台无关的语言；一种健壮的语言，吸收了C/C++的优点，但去掉了其影响程序健壮性的部分（如：指针、内存的申请与释放等） Java的两种核心机制 Java虚拟机（Java Virtual Machine） 垃圾回收机制（Garbage Collection） 源程序（*.java文件）→Java编译器→字节码（*.class文件）→类装载器→字节码校验器→解释器→操作系统平台 一次编译，随处运行 Java是一种解释型语言 JDK(Java Development Kit)软件开发工具包 JRE(Java Runtime Environment)运行时环境 开发需要JDK；用户只需JRE PATH:WINDOWS系统执行命令时要搜寻的路径（如javac.exe，java.exe）CLASSPATH:Java在编译和运行时要找的class所在路径（“.”代表当前路径） java：运行java程序 javac：编译java程序 java –version 一个源文件最多只能有一个public类，其他类数量不限，源文件名必须与public 类名一致 Java应用程序的执行入口时main（）方法：public static void main(String[] args){…} Java语言中严格区分大小写 编译后，每一个类都对应一个class文件 第2章基础语法 标示符由字母、下划线”_”、美元符”$”或数字组成 标示符应以字母、下划线、美元符开头 Java标示符对大小写敏感，长度无限制，注意“见名知意”且不能与Java语言关键字重名 goto和const虽然未使用，但也被作为Java的关键字保留史上最全Java基础知识点归纳
java知识点总结
java基础知识点总结
《Java编程基础知识点汇总及习题集》--答案
java面向对象知识点总结
JAVA技术--Java基础知识常见考试题JAVA技术.doc
《Java编程基础知识点汇总及习题集》--答案
java各知识点详细总结(毕向东笔记整理)
java期末考试知识点总结
Java基础阶段复习题2(附答案)
java基础刷题知识点总结
javaweb知识点总结
java基础知识练习题
Java期末知识点整理总结
java基础知识详细整理(图文并茂深入浅出)
Java基础知识整理教学教材
java各知识点详细总结
Java学习知识点情况总结
Java知识总结完整版