java学习小结

总结对于个人的成长而言，是我们反思自身、了解自身、明确目标的重要方式，通过编写的总结报告，我们可以在工作回顾中，寻找出自身的工作难点，掌握自身的工作优势，更加明确自身的发展方向。今天小编给大家找来了《java学习小结》的相关内容，希望能给你带来帮助!

第一篇：java学习小结

菜鸟 的java学习小结

Java学习小结

一、7月11日

1.DOS命令

dir指令：显示文件; help指令：显示命令条数;

ipcofig指令：显示计算机的ip地址等信息。 2.java的理论概括

面向对象：对现实世界进行抽象概括;

跨平台性：java虚拟机的不夸平台实现了java语言的跨平台性。

二、7月12日

1.右击sourceGenerate Getters and Setters„

自动生成get和set方法 2.1个字节=8位 char 1个字节 int 4个字节 3.java的构成

数据类型、变量、运算符、控制流语句 4.基本数据类型：

byte、char、boolean、short、int、long、float、double 引用数据类型：

数组、类(包括基本数据的引用类型)、接口

5.I/O阻塞 System.in.read() 第一种用法：

int c=System.in.read(); System.out.println((char)c); 第二种用法：

Scanner s=new Scanner(System.in); String name=s.nextLine();

int age=s.nextInt(); 6.InputStreamReader bi=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(bi); String s=br.readLine(); 7.把字符串类型的b转换为整型 int a=Integer.parseInt(b) 8.设置智能提示

WindowPreferences输入“editor”JavaEditorContentAssist (在写“.”的框里写个特殊字符，以便在导出的文件中便于查找) 导出(FileExportPreferences„)修改(找到带点的地方，输入24个字母的大小写)导入(FileImportPreferences„) 9.导出jar包操作

ExportJava Jar选工程、保存位置选main class 创建快捷方式输入“java –jar D:ss.jar(路径)” 或者直接导出单独的可运行程序(xx.jar) 10.数据类型转换

自动类型转换的条件：两种类型兼容、目标类型大于源类型。 11.eclipse使用技巧： “Ctrl”+“/”

“Alt”+“/”

“Alt”+小键盘

多行注释或者取消注释 跳出提示 ASCⅡ码输入法

syso+“Alt”+“/” 输出System.out.println() main+“Alt”+“/” 输出public static void main(String[] args)

三、7月13日

1.编译器代表一个可执行文件，如javac 2.Override 重写、覆盖 重新定义

Overload 重载 一个类中存在多个同名方法 3.char c=s.charAt(0); 把字符串s的第0个字符转换为char型，赋给c

4.“ctrl”+“shif”+“F”

右击sourceFormat

自动对齐

四、7月14日

1.List list=new ArrayList(); List.add(“hello”); 代表列表list中元素的类型，此处为字符串 2.abc:while(){„{„break abc„}„} abc表示标号 3.OOP:面向对象编程 OOA:面向对象分析 OOD:面向对象设计

4.消息指一个对象为执行某项特定操作而向另一个对象传递的数据

5.javascript如果要在声明框架的网页(框架网页)中插入，就一定要在之前插入，否则这些代码是不会执行的。 6.for-each循环(用于遍历数组或者列表、集合) int[] a={3.4.5.2}; for(int k:a) {

} System.out.println(k);

五、7月15日

1.产生一个随机数

Random rd=new Random(); rd.nextInt(100); 0-100的整型随机数 2.JFrame类

JFrame jf=new JFrame(); jf.setVisible(true);设置jf窗体为可见 jf.setLayout(new FlowLayout());设置布局格式 JButton jb=new JButton()

jb.setText(“ok”); 设置按钮的文字 3.File类

File f=new File(“D:a.txt”);把此文件映射成f对象 f.delete();删除文件

六、7月16日

1.FileOutputStream类 用于往文件对象中写东西

FileOutputStream fos=new FileOutputStream(“D:/a.txt”); BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(fos)); 2.FileInputStream类 用于读取文件

FileInputSream fis=new FileInputStream(“D:a.txt”); BufferedReader br=new BufferedReader(new InputStreamReader(fis));

String s; While((s=br.readLine())!=null && s.length()>0) { String[] ss=s.split(“,”); //以“，”为分隔符，把s中的各部分依次导入到数组ss中

} 3.String.valueOf(int t) 把t转换为字符串类型 ZhiGong z=new ZhiGong(ss[0],Integer.parseInt(ss[1]));

七、7月18日

1.右击sourceOverride„

用于重写

2.在生成子类对象时会自动调用父类的默认构造方法;如果父类没有默认的构造方法，则必须在子类的构造方法中显示的调用父类的构造方法。并且必须写在第一行。

super()或者super(参数列表)。 3.权限修饰符 public:

所有类都可以访问

private:

只有该类可以访问

该类及其子类、同一包中的类可以访问 相同数据包中的类可以访问 protected: 默认: 4.static：

①可以调用其他静态方法

②只能访问静态数据

③不能使用super或者this关键字 final：

①修饰类，不能被继承

②修饰字段，可以被引用，但不能被修改 abstract：抽象

①抽象类里面可以有抽象方法 ②抽象类不可以实例化

③非抽象子类必须实现抽象父类的全部抽象方法

八、7月20日

1.switch-case中case后面不能用变量 2.Thread 线程

①使用方法一：

public class Thread1 {

public static void main(String[] args) {

Runner1 r=new Runner1(); Thread t=new Thread(r); t.start(); } } class Runner1 implements Runnable {

} public void run() {

} for(int i=0;i<30;i++){ } System.out.println(“No.”+i); ②使用方法二：编写一个类继承Thread类，重写Thread类的run方法，然后直接new该类的对象使用。

③使用方法三：直接在代码里写线程

new Thread(new Runnable(){

public void run() { //写代码

}

}).start(); ④isAlive()：判断线程是否还“活”着，即线程是否终止

⑤wait()：当前线程进入对象的wait pool; notify()/notifyAll()：唤醒对象的wait pool中的一个/所有等待线程 ⑥线程的优先级用数字表示，范围1-10，值越大优先级越高(但不一定优先级越高，线程就会先执行)

getPriority()/setPriority(iint i) 获取/设置线程的优先级 ⑦线程串行化

thread.join()

要等thread线程执行完才能执行其他线程

先执行thread指定时间，然后和其他线 join(毫秒),join(毫秒，纳秒) 程并发执行

⑧线程让步：放弃当前获得的时间片，重新进入就绪状态

thread.yield(); ⑨线程挂起：暂时停止当前运行中的线程，使之转入阻塞状态，并且不会自动恢复运行。

线程恢复：使得一个已挂起的线程恢复运行。

suspend() 挂起; resume()恢复 3.枚举 enum

public enum Week { } 以“Week.***”的格式来使用，Week可以看成一种变量类型。 MON,TUE,WED,THU,FRI,SAT,SUN

九、7月21日

1.接口(interface)

①里面一般只有方法，也可以定义静态常量 例如：public static final int i=0; ②只能是public或默认的 2.反射

①第一种情况：未知类采用默认构造方法

Class cls=Class.forName(getClassName()); Object obj=cls.newInstance(); Method m=cls.getMethod(getMethod(), new

Class[]{int.class,int.class});

m.invoke(obj,new Object[]{5,7}); private static String getClassName() { } private static String getMethod() { } ②第二种情况：未知类采用带参数的构造方法

return "abc.AA"; return "add";

Class cls=Class.forName(getClassName()); Constructor cr=cls.getConstructor(new Class[]{int.class,String.class});

Object obj2=cr.newInstance(new Object[]{12,"king"}); Method m2=cls.getMethod(getMethod(), new Class[]{}); m2.invoke(obj2,null); private static String getClassName() { } private static String getMethod() {

} 3.异常

throws(抛出异常类型)/throw(抛出具体异常); try,catch,finally return "add"; return "abc.AA";

十、7月22日

1.常用类

Math、Class、Object、String/StringBuffer、Date/Calendar/Random 2.集合

(此图引自《java se 应用程序设计》视频教程) ① 集(Set)

不区分元素的顺序，不允许插入重复的元素 ② 列表(List)

区分元素的顺序，并且允许插入重复的元素 ③映射(Map)

映射中保存成对的“键-值”(key-value)信息，映射中不能包含重复的键，每个键最多只能映射一个值

十一、7月25日

1. 进程、线程

① 进程就是一个程序，线程就是程序中的代码块。进程包含线程 ② 子线程与父线程都是并列执行的 2. synchronized 同步线程

① 当某个对象用synchronized修饰时，说明该对象在任一时刻只能由一个线程访问

② 用于方法说明中，标明整个方法为同步方法

public synchronized void push(){„} ③ 用于修饰语句块，标明整个语句块为同步块

public char pop(){„

synchronized(this<对象>){„}„} 3.使用String类型的getBytes()方法获得Byte数组

十二、7月26日

1. DataInputStream和DataOutputStream 用于读取写入二进制文件 2.字节流 8位

字符流 16位

十三、7月27日

1. 监听器 2. model 3. 半相关：地址、协议、端口号

全相关：半相关一致(地址可以不同) //两点通信的条件

ServerSocket(服务器端<半相关>)、Socket(客户端/服务器端<全相关>)

十四、7月28日

1.Socket网络编程的步骤

① 建立网络连接----获得全相关

② 打开连接到Socket的输入/输出流----getInputStream/getOutputStream ③ 通过已打开的I/O流进行数据的读/写操作 ④ 关闭已打开的I/O流和Socket 十

五、7月29日

1. protected不能修饰局部变量 abstract不能修饰属性

2. ImageIO.read(); //获取图片文件的一种方法

十六、8月1日

1. 单例模式：确保某个类只有一个对象

① 虚拟机上的单例 class A {

private static boolean a=false;//用来判断对象是否存在 private A()//私有化构造函数，使其他类不能new { } public static A getInstance()//获得该类实例的唯一方法 {

} } ② 操作系统上的单例

在计算机上建个文本文件，里面标记该类是否存在实例，关闭实例时要把文件里的标记还原。 if(a==false) {

} else return null; a=true; return new A(); 十

七、8月2日

1.p instanceof Student 判断p是否是Student类的实例

2.**.getClass().getResource(“user.dir”);

获取当前路径

3. .... 上一层的上一层

十八、8月3日

1. 随机读取文件RandomAccessFile

seek(long pos) 定位到pos处

2. 标准对话框(javax.swing.JoptionPane) 用于实现程序员与用户的便捷交互

姓名：wdbsking 电话：1508864759*

第二篇：java路径问题小结

1.user.dir Java代码

1. //通过来获取;此目录并非是固定的，而是根据该代码所属类运行时的环境而定。

2. //普通的java程序中获得的是该类所属项目的根目录(d:workspaceapp) 3. //在特定服务器下发布运行的javaweb程序则获得的是该服务器下提供运行环境的目录

4. //(如用Tomcat将获得F:Tomcat 6.0in) 5. System.getProperties("user.dir")

2.classes目录

顾名思义指存放类文件的根目录。

普通java程序的classes目录指appin  web项目的classes目录是指appWebRootWEB-INFclasses 

Java代码

1. //在普通项目或web项目中

2. //s:获得classes目录绝对路径(包括TestClass类所属包目录) 3. // appincom est 4. // 或appWebRootWEB-INFclassescom est 5. //ss:获得classes目录绝对路径 6. // appin 7. // 或appWebRootWEB-INFclasses 8. com.test.TestClass c=new com.test.TestClass(); 9. String s=c.getClass().getResource("").getPath(); 10.String ss=c.getClass().getClassLoader().getResource("").getPath();

3.web项目根目录(在服务器发布后) app

(1)根据ServeletContext的getRealPath()方法获得绝对路径 Java代码

1. //第一种获得"app"绝对路径f: omcat 6.0webappsapp 2. //第

二、三种获得"app"绝对路径f: omcat 6.0webappsapp 3. getServletContext.getRealPath(""); 4. getServletContext.getRealPath(""); 5. getServletContext.getRealPath("/");

(2)根据HttpServletRequest的getContextPath()方法获得相对路径 Java代码

1. getRequest().getContextPath();

4.在struts2框架中获得发布后web项目的根目录 Java代码

1. //利用ServletActionContext的静态方法

2. String real=ServletActionContext.getServletContext().getRealPath(""); 3. String relative=ServletActionContext.getRequest().getContextPath());

如果使用user.dir的值的话获得的路径为%Tomcat_Home%in,所以不推荐使用user.dir这一环境变量来获取路径。

对于新手来说，搞清楚java项目的开发目录和发布目录的信息是十分必要的，特别是使用集成开发环境下，目录的安排十分透明，如果脱离开发环境的话，很多新手都会对项目目录结构很迷茫。

第三篇：java知识点小结

java重要知识点总结如下：

1，抽象，封装，继承，多态是面向对象程序设计中得四个特点.

2，面向对象得软件开发大体分为：面向对象的分析，面向对象的设计，面向对象的实现.

可概括为如下过程：分析用户需求，从问题中抽取对象模型;细化模型，设计类，包括类的属性和类间的

相互关系，同时观察是否有可以直接引用的已有类或部件;选定一种面向对象的编程语言，具体编码实现

上一阶段类的设计，并在开发过程中引入测试，完善整个解决方案.

3，面向对象程序设计方法的优点是：可重用性，可扩展性，可管理性.

4，类的定义：class前的修饰符分为访问控制符和非访问控制符两大类.访问控制符包括public和private.

非访问控制符包括abstract(抽象)，final(最终).

5，final类是最终类，是不能有子类的类.abstract和final不能同时修饰一个类，因为抽象类本身没有具体对象，

需要派生出子类后在创建子类的对象.而最终类不可能有子类.

6，创建对象的格式为： 类名 对象名=new 构造方法(参数);注意前面是类名后面是构造方法.

注意构造方法没有返回类型，也不能写void，主要用于完成类对象的初始化工作，一般不能直接由编程

直接调用，而是用new运算符来调用.

7，如果class前面由public修饰符，则默认构造方法的前面也应该有public修饰符.

8，类中有static修饰的域或方法，可用类名或对象名访问，否则只能用对象名访问.

9，修饰域的访问控制符可以是：public，private，protected，private protected.非访问控制符可以是：

static，final，volatile(易失域)

10，类变量的最本质的特点是：他们是类的域，不属于任何一个类的具体对象实例.不是保存在某个对象实例的内存空间中，而是保存在类的内存区域的公共存储单元中. 11，局部变量是在方法体内声明的，只有当方法被调用时他们才存在，因而只能在本方法内使用，不存在访问控制符，也不能声明为静态变量(static)，但可以声明为final变量.局部变量必须初始化.

12，修饰方法的访问控制符可以是：public，private，protected，private protected，修饰方法的非访问控制符可以是：static，final，abstract，native(本地方法)，synchronized(同步方法)。

13，用static修饰的变量或方法都为类成员，类成员可以用类名或实例名访问，实例成员只能用实例名来访问。

14，如果一个类中含有抽象方法，则此类必须为抽象类，如果抽象类的子类不为抽象类，则子类必须实现父类的所有抽象方法。抽象方法不能用静态方法和最终方法。抽想方法只有函数头的声明，而用分号来替代方法体，没有大括号。如abstract void abstractmethod();

15，this变量用在一个方法的内部，指向当前对象，当前对象指的是调用当前正在执行的方法的那个对象。super变量是直接指向父类的构造方法，用来引用父类种的变量和方法。(由于他们指的是对象，所以不能通过它来引用类变量和类方法)

16，如果要引用一个包中的多个类，可以用星号来代替。使用星号只能表示本层次的所有类，而不包括子层次下的类。所以经常需要用两条语句来引入两个层次的类：import java.awt.*;import java.awt.event.*;

17，访问修饰符：

--类中限定为public的成员可以被所有的类访问。

--类中先定位private的成员只能被这个类本身访问。同一个类的不同对象可以访问对方的private域变量或调用对方的域方法，这是因为访问保护控制在类的级别上，而不是对象的级别上。

--类中限定为protected的成员可以被这个类本身，它的子类(包括同一个包中和不同包中的子类)，以及同一个包中的其他类访问。

--用private protected修饰的成员可以被该类本身访问，也可以被该类的所有子类访问。

--默认访问控制符规定只能被同一个包中的类访问和引用，而不能被其他包的类访问。即他的访问权限是friendly。

18，注意：

----abstract和private，static，final，native不能并列修饰同一个方法。

----abstract类中不能有private修饰的域和方法

----static方法不能处理非static的域。

19，重载方法的参数必须不同，或者是参数个数不同，或者是参数类型不同。重载的多个方法必须返回相同的数据类型。

20，在java中，一个类获取某一接口定义的功能并不是通过直接继承这个接口的属性和方法来实现的。因为接口中的属性都是常量，接口的方法都是没有方法体的抽象方法，没有具体定义操作。

第四篇：java中this&super的用法小结

This : this关键字必须放在非静态方法里面

this关键字代表自身，在程序中主要的使用用途有以下几个方面： 1. 使用this关键字引用成员变量

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，有些时候可以省略，有些时候不能省略。

eg1. public class ReferenceVariable {

} private int a;

public ReferenceVariable(int a){ this.a = a; }

public int getA(){ return a; }

public void setA(int a){ this.a = a; }

按照Java语言的变量作用范围规定，参数a的作用范围为构造方法或方法内部，成员变量a的作用范围是类的内部，这样在构造方法和setA方法内部就存在了变量a的冲突，Java语言规定当变量作用范围重叠时，作用域小的变量覆盖作用域大的变量。所以在构造方法和setA方法内部，参数a起作用。

这样需要访问成员变量a则必须使用this进行引用。当然，如果变量名不发生重叠，则this可以省略。

但是为了增强代码的可读性，一般将参数的名称和成员变量的名称保持一致，所以this的使用频率在规范的代码内部应该很多。 2.使用this关键字在自身构造方法内部引用其它构造方法, this语句是是构造函数的第一个语句，它的形式是this(参数表)

在一个类的构造方法内部，也可以使用this关键字引用其它的构造方法，这样可以降低代码的重复，也可以使所有的构造方法保持统一，这样方便以后的代码修改和维护，也方便代码的阅读。

public class ReferenceConstructor { int a; public ReferenceConstructor(){ this(0); //调用了另一个构造方法

} public ReferenceConstructor(int a){

this.a = a; } }

这里在不带参数的构造方法内部，使用this调用了另外一个构造方法，其中0是根据需要传递的参数的值，当一个类内部的构造方法比较多时，可以只书写一个构造方法的内部功能代码，然后其它的构造方法都通过调用该构造方法实现，这样既保证了所有的构造是统一的，也降低了代码的重复。

在实际使用时，需要注意的是，在构造方法内部使用this关键字调用其它的构造方法时，调用的代码只能出现在构造方法内部的第一行可执行代码。这样，在构造方法内部使用this关键字调用构造方法最多会出现一次。

3.

使用this关键字代表自身类的对象

在一个类的内部，也可以使用this代表自身类的对象，或者换句话说，每个类内部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this。 eg1. public class ReferenceObject { ReferenceObject instance; public ReferenceObject(){

instance = this; } public void test(){

System.out.println(this); } }

在构造方法内部，将对象this的值赋值给instance，在test方法内部，输出对象this的内容，这里的this都代表自身类型的对象。

4. 使用this关键字引用成员方法

在一个类的内部，成员方法之间的互相调用时也可以使用“this.方法名(参数)”来进行引用，只是所有这样的引用中this都可以省略。

Super

1.在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

2.当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

3.当子类的成员方法覆盖(重写)了父类的成员方法时，也就是子类和父类有完全相同的方法定义(但方法体可以不同)，此时，用“super.方法名(参数列表)”的方式访问父类的方法。 eg1. class Country{

String name;

void value()

{ name="China"; }

} class City extends Country{

String name;

void value()

{

name="Beijing";

super.value();

System.out.print(name); //父类的成员变量被覆盖

System.out.print(super.name); //输出父类成员变量

} //输出的结果为 Beijing China Static 1.在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。

class Simple { static void go() { System.out.println("Go..."); } } public class Cal { public static void main(String[] args) { Simple.go(); } } //输出为Go. . .，调用一个静态方法就是“类名.方法名”

2.静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间。 eg1. class Value { static int c=0; static void inc() { c++; } }

class Count { public static void prt(String s) { System.out.println(s); } public static void main(String[] args) { Value v1,v2; v1 = new Value(); v2=new Value(); prt("v1.c="+v1.c+" v2.c="+v2.c); v1.inc(); prt("v1.c="+v1.c+" v2.c="+v2.c); } } //结果：v1.c=0 v2.c=0 v1.c=1 v2.c=1 //都显示为1，但是只调用了v1.inc()，可以证明它们共享一块存储区

eg2.class Value { static int c=0; Value() { c=15; } Value(int i) { c=i; } static void inc() { c++; } } class Count { public static void prt(String s) { System.out.println(s); }

//static定义的变量会优先于任何其它非static变量,虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面

Value v=new Value(10); static Value v1,v2;

//在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一//次，且在类被第一次装载时。 Static { prt("v1.c="+v1.c+" v2.c="+v2.c); v1=new Value(27); prt("v1.c="+v1.c+" v2.c="+v2.c); v2=new Value(15); prt("v1.c="+v1.c+" v2.c="+v2.c); } public static void main(String[] args) { Count ct=new Count(); prt("ct.c="+ct.v.c);//这句? prt("v1.c="+v1.c+" v2.c="+v2.c); v1.inc(); prt("v1.c="+v1.c+" v2.c="+v2.c); prt("ct.c="+ct.v.c); } }

//运行结果 v1.c=0 v2.c=0 v1.c=27 v2.c=27 v1.c=15 v2.c=15 ct.c=10 v1.c=10 v2.c=10 v1.c=11 v2.c=11 ct.c=11

3.通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类 . eg1. public class StaticCls{ public static void main(String[] args){ //注意此处用法，创建一个类的内部类对象

OuterCls.InnerCls oi=new OuterCls.InnerCls(); } } class OuterCls{ public static class InnerCls{ InnerCls(){ System.out.println("InnerCls"); } } //结果：InnerCls

Final Final成员： 1. 在类中定义变量加上final关键字，那便是说，这个变量一旦被初始化便不可改变(对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变)。其初始化可以在两个地方，一是其定义处，，二是在构造函数中。这两个地方只能选其一。

2. 方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用

eg.

public class INClass{ void innerClass(final String str){ class IClass{ IClass(){ System.out.println(str); } } IClass ic=new IClass(); } public static void main(String[] args){ INClass inc=new INClass(); inc.innerClass("Hello"); } } Final方法：

1.final方法不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法(即可以直接使用)。

2.inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用

Final类：

一个final类是无法被任何人继承。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。

常量的定义：final static 定义时候：多次引用的字符串和数字等需要定义常量。

定义地点：根据引用的范围(同一个类、不同类)：类中、单独的常量类或者接口。 如何定义：常量的定义处需要详细的注释。

第五篇：Java学习心得

专业：信息与计算科学班级：

姓名：学号：

日期：

河北建筑工程学院数理系

java语言产生于C++语言之后，是完全的面向对象的编程语言，充分吸取了C++语言的优点，采用了程序员所熟悉的C和C++语言的许多语法，同时又去掉了C语言中指针、内存申请和释放等影响程序健壮性的部分，可以说java语言是站在C++语言这个"巨人的肩膀上"前进的。

java采用的是相对简单的面向对象技术，去掉了运算符重载、多继承的复杂概念，而采用了单一继承、类强制转换、多线程、引用(非指针)等方式。

在java程序中不能采用地址计算的方法通过指针访问内存单元，大大减少了错误发生的可能性;而且java的数组并非用指针实现，这样就可以在检查中避免数组越界的发生。

Java语言学习要点

一、掌握静态方法和属性

静态方法和属性用于描述某一类对象群体的特征，而不是单个对象的特征。Java中大量应用了静态方法和属性，这是一个通常的技巧。但是这种技巧在很多语言中不被频繁地使用。理解静态方法和属性对于理解类与对象的关系是十分有帮助的，在大量的Java规范中，静态方法和属性被频繁使用。因此学习者应该理解静态方法和属性。Java在方法和属性的调用上是一致的，区别只表现在声明的时候，这和c++是不同的。

二、重视接口

在面向对象早期的应用中大量使用了类继承。随着软件工程理论

的不断发展，人们开始意识到了继承的众多缺点，开始努力用聚合代替继承。软件工程解决扩展性的重要原则就是抽象描述，直接使用的工具就是接口。接口近年来逐渐成为Java编程方法的核心。另一方面，就应用而言，大部分开发是建立在规范基础之上的，不需要自己建立复杂的继承关系和庞大的类。因此读懂规范和用好规范已经成为应用程序开发人员的首要任务，Java各项规范的主要描述手段就是接口。

三、学好集合框架

Java描述复杂数据结构的主要方式是集合框架。Java没有指针，而是通过强大的集合框架描述数组、对象数组等复杂的数据结构。学好这些数据结构的描述方法对于应用程序编写，特别是涉及到服务器方、3层结构编程至关重要。程序员在这个时候不能再用诸如数据库结果集之类的结构描述数据了。

四、例外捕捉

Java对例外捕捉的强调是空前的，它强迫程序员用显著的与逻辑方法完全不同的方式描述例外捕捉，对于程序描述的完整性和严谨性有很大的意义。

总之学编程语言不仅仅是从理论上的学习，更重要的是要利用这门语言为你的思想服务。理解这门语言是首要的，但是要达到心领神会、融会贯通就必须勤动手，多去时间，多编一些例子。计算机科学是注重实践的学科，成功的软件开发人员无不经过大量的上机锻炼，只有理论和实践相结合才能真正掌握只是和技能。