Java是一种OOP语言工具，而不仅仅是编码
API(Application Programming Interface,应用程序编程接口)是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
java发展史
sun公司成立与1982年，java诞生与1991年（实际上此时出现了跨平台），1993年计算机网络，1995年java实际的诞生日，1996年jdk（java developkit java开发工具包）1996年底 jdk1.1 1997年ejb（enterprise javabean j2ee的一部分）出现，ejb时sun的服务器端组件模型最大用处时部署分布式应用程序，类似微软的.com技术，凭借java跨平台的优势，用ejb【EJB是sun的服务器端组件模型，最大用处是部署分布式应用程序，类似微软的.com凭借java的跨平台优势，用EJB技术部署的分布式补充可以不限与特定的平台】技术部署的分布式补充可以不限于特定的平台；1998年jdk1.2 发布java2.0 （包括j2se【桌面系统，简单电子商务】 j2ee【大型web应用程序】 j2me【嵌入式开发】） 现在是java1.6（是测试【beta】版本，不完善）。
java是一种面向对象语言，是一种跨平台的语言，集合c与c++的优点，去掉了一些不合理的地方，提供多线程机制。
java与c和c++的区别：（1） java程序中，不能在所有类之外定义全局变量，只能通过在一个类中定义公用，静态的变量来实现一个全局变量。java对全局变量进行了更好的封装。而在c和c++中，依赖于不加封装的全局变量常常会早晨个系统的崩溃。（2）java不支持c和c++中的goto语句，而时通过异常处理语句try，catch，finally等来代替c和c++中的goto来处理遇到错误是跳转的情况，使程序更可读且更结构化。（3）指针时c和c++中最灵活的，也是最容易产生错误的数据类型。由指针所进行的内存地址操作常会造成不可预知的错误，同时通过指针对某个内存地址进行显示类型数据转换后，可以方为一个c++中的似有成员，从而破坏了安全性，造成系统的崩溃。而java对指针进行完全的控制，程序员不能直接进行任何指针操作。例如。吧整数转化成指针，或者通过指针释放某一内存地址等。同时，数据作为类在java中实现，很好的解决了数据访问越界这一c和c++中不做检查的错误。（4）在c中，程序员通过库函数malloc（）和free（）来分配和释放内存，c++中则通过运算符new和delete来分配内存和释放内存。再次释放已释放的内存块或未被分配的内存块，会造成系统的崩溃；同样，忘记十方不再使用的内存块也会逐渐耗尽系统资源。而在java中，所有的数据结构都是对象，通过运算符new为他们分配内存。通过new得到对象的处理权，而实际分配给对系那个的内存可能随程序运行而改变，java对此自动的进行管理并且进行垃圾收集，有效地防止了由于程序员的错误操作而导致的错误，并且更好的利用了系统资源。（5） 在c和c++中，对于不同的平台，编译器为简单数据类型，如 int，float等分别分配不同长度的字节数，例如，int在IBM PC中为16位，在VAX-11中为32位，这导致了代码的不可移植性，但在java中，对于这些数据类型总是分配固定长度的位数，如对int型，它总占32位，这就保证了java的平台无关性。(6)在c和c++中，由于可以通过指针进行任意的类型转换，因此常常带来不安全性；而java中，系统在运行时对对象的处理要进行类型相容性检查，以防止不安全的转换。（7）c和c++中用头文件来声明类的原型及全局变量，库函数等，在大的系统中，维护这些头文件是很困难的。而java不支持头文件，类成员的类型和访问权限都封装在一个类中，运行时系统对方问进行控制，防止对私有成员的操作，同时，java中用import语句来与其他类进行通信，一使用他们的方法。（8）c和c++中的结构和联合中所有成员均为共有，这就带来了安全性问题。java中不包括结构和联合，所有的内容都封装在类中。（9）在java中，不支持宏，它通过关键字final来声明一个常量，以实现宏定义中广泛使用的常量定义。
java语言目的：1 思想可重用组件可独立进行，也可以按各种方式与其他组件合成不同的应用程序系统。
（JavaBean（模块）是组件，即类和其所需资源的集合，主要被设计用来提供定制的GUI小配件。）
2 实现联网功能：applet，socket通信，RMI(remote method invoke 远程方法调用)【是java自己的对象请求代理技术，它使得应用程序能够跨越网络来调用执行在其他java应用程序内的方法。】，web servlet和JSP(java server pages)。
java的核心机制：jvm和gc（垃圾回收机制）。jvm可以理解为以字节码为指令的虚拟cpu，不同os上的jvm不同，真正跨平台是jvm，字节码文件对应不同的jvm，从而实现“一次编译，到处运行。”电脑中不用的内存称为垃圾，java虚拟机时刻在监视，当不用的时候就由jvm调用gc在空闲时间回收无用内存（当对象不再被使用的时候就称为垃圾或者指针不再指向该对象的时候）,gc在java中是由程序员无法精确控制的。
面向对象的核心机制是：封装，继承和多态。
J2SE包括应用程序(Application)和小应用程序(applet)。应用程序是以main（）方法作为程序入口的程序称为java应用程序，而小应用程序则没有main()方法，它是通过支持java的浏览器或者Appletviewer运行。
Path是外部命令执行的路径:
查看 set ***（称为键）
set *** = ***；*（称为键值）
【取消环境变量即值赋值微NULL即可。】
java应用程序开发与运行
java跨平台原理时由jvm来实现的
java编译程序将java源程序翻译为jvm可执行代码——字节码（这一编译过程同c，c++不同，当c编译器编译生成一个对象的代码时，该代码时为在某一个特定硬件平台运行而产生的,因此，编译中所有对符号的引用在转成特定的内存偏移量，保证程序运行。java编译器把这些符号引用并保留在字节码中，由解码器在运行过程中创建内存布局，进而通过查表来确定一个方法所在的地址，即设保存与特定平台相关的信息，保证了java的可移植性与安全性。）
java 跨平台原理
（1）程序语言的种类（按执行方式）
编译型 使用专门的编译器针对特定的操作系统平台，将某种高级语言书写的源程序一次性的翻译成该平台的硬件所识别的机器码。《指令，操作数》
程序语言要执行，必须一机器码指令的方式在某种硬件平台和操作系统平台上运行。
不同的硬件平台和操作系统所识别的机器码指令格式是不一样的。
优点：执行速度快
缺点：内存消耗大，可移植性差
解释型 使用专门的解释器将某种高级语言书写的源程序逐条解释称该平台的某种os平台和硬件平台所能识别的机器码并且立即执行，解释一条执行一条。
优点：内存消耗小，可移植性高
缺点：执行速度慢《方法执行一次要翻译一次》
（2）java语言《编译，解释语言》
现将java源程序编译成一个与平台无关的中间产物，即字节码文件，然后通过java解释器再将其翻译成与平台关联的机器码并执行。
该java解释器由java运行环境调度运行。
分析：
1，java语言的编译过程与其他语言的编译过程的区别
其他语言的编译过程 编译型程序在编译过程中所产生的文件是为了能在特定平台上运行而产生，故在编译过程中必须将程序中对变量和方法引用要转化为特定的内存地址的引用，即在编译过程中必须建立好特定的内存布局。
2 java语言编译过程
java只是简单地将java源文件翻译成.class的字节码文件，而将对程序中的变量和方法引用都保留在该字节码文件中。 由java解释器在执行实在针对特定平台建立内存布局。
|
Java编译过程（jdk） |
|
Java源文件 |
|
Java编译器 |
|
字节码文件 |
|
本地或网络 |
|
类加载器 |
|
类库 |
|
Java解释器 |
|
即使编译器 |
|
Java运行环境 |
|
Os |
|
硬件 |
|
Java运行过程（jre） |
Java语言的一个重要功能特点是内置对多线程的支持。
javac jvm javaw os之间的关系
javaw编译器无需面向特定的os，只需面向特定的jvm，产生jvm能识别的字节码，该字节码有jvm读取并交给javaw解释器，java解释器再将该字节码解释成机器码然后再特定的平台上运行。
（jdk中的java解释器是不同的，因此jdk的版本不同，要与对应的运行平台对应，虚拟机的运行是一样的。）
jvm的结构和功能
结构：内存，寄存器，，指令集，垃圾收集器，cpu
功能：加载要执行的字节码文件，管理分配内存，执行垃圾回收。
jvm是一种利用软件方法来实现的抽象化的计算机，基与下层的操作系统和硬件平台，可以再上面执行java的字节码程序
由于硬件平台不一致，因此jvm使用了堆栈，帧的概念，来从放一下信息： 表示方法状态的帧，字节码操作数，传递给方法的参数，局部变量。
java可以用来生成两类程序
桌面应用程序 GUI web应用程序（Applet ，jsp，servlet等）
Java环境变量
1） 环境变量：指os中定义的变量，给os的应用程序使用.
2） 设置环境变量： 命令行设置环境变量：set classpath=d:/tang/ch04、;c:/java/classes;
3） 查看环境变量： set
1 %环境变量名% 指取得环境变量的当前值。
2 在命令行窗口中定义的环境变量只对当前窗口有效，对其它窗口无效。
3 在我的电脑中设置的环境变量只对设置之后启动的应用程序有效。
4 设置环境变量使用等号前后不能有空格。
Path环境变量：定义os运行时要查找的应用程序的路径，os首先会在当前目录下去查找要执行的程序，如果当前目录下不存在，就会在path设置环境变量定义的路径中去查找，以最先找到的为准。
1 找到的第一个程序若是无法运行，DOS只会报错而不是用第二个。
2 当前目录：启用应用程序所在目录要运行的程序所在目录。
3 DOS中当前目录用“.”表示，cd ..表示返回上级目录，cd../..表示返回上上级目录。
【环境变量名和环境变量之后总不能包含中文字符。】
Java应用程序开发
1） 1 java是一类（.class）微单位来组织程序，以java作为源文件保存程序。
2 要让JVM能够直接运行一个字解码文件，该类必须存在一个特定的main（）方法。
3 编译是指编译某一目录下的java源文件，运行是指运行某一目录下的自解码文件。
4 classpath环境变量，描述java虚拟机要查找的源文件的路径，jvm会先到当前目录下查找要执行的程序，如果当前目录下不存在，就会在path设置环境变量定义的路径中去查找，以最先找到的为准。
2） java运行环境的结构
1 类加载器（classloader）负责运行一个程序是所需的全部代码的加载工作。
2 字节码校验器:对运行时的程序惊醒数据转换或栈溢出与已成检查。【不是编译时检查】
3 解释器：负责执行程序代码
方法;1 编译执行方式 （把整个字节码---机器码，之后运行）
2 解释执行方式 （解释一小段代码来完成整个字节码）
一般用java解释器，因为即使编译器要求内存高，解释执行方式更节省内存。
Package和import
为便于大型软件管理与系统中数目众多的类，Java提供package管理机制。
Package语句作为java源文件的第一条语句，指明该文件中定义的类所在的包。
格式：package pkg[.pkg1[]….] ‘.’表示目录的层次
Eg：package java.awt.image;制定包中文件在目录java/awt/image下。
包层次的根目录是由环境变量classpath来确定的。
用包管理的源文件编译成字节码文件后把字节码文件放到对应的包中去。
Javac 源文件 （编译） Java 包名+类名（运行）
只要包不一样，那么类名一样是没有关系的
即：java cn.com.HelloWorld
Java.cn.vo.HelloWorld
执行的结果是一样的。
Import语句引入所属的类<导入不同包中的类，且导入的类需要先编译>
格式：import package1[.package2[]….] (classname 1*)；
其中package pkg[.pkg1[]….]与package语句相同，表包层次，对应于文件目录。
Classname则要指明两个要引入的类，如果要引入多个类，则用（*）代替。
Eg：import java.awt.*; 【*只表示本层次的所有类，不包括子类层次的类】
Import java.utill.Date;
Java源文件目录放在src文件下
字节码放在classes文件下
可执行文件放在bin目录下
第三方组件放在lib文件下
API文档放在doc文件下
Cd进入文件 dir可查看文件下的东西 javac 编译java源文件 java 类名（用于执行一个字节码文件）
运行时要制定字节码文件 放到classes中的指令如下：
javac –d ../classes HelloWorld.java
全部编译：javac *.java
java应用程序
public class HelloWorld{
public static void main(String [] args){
System.out.println("HelloWorld");
}
}
分析：用保留字class来声明一个新类，static指明该方法是一个类方法，可以通过类名直接调用，public表示访问权限，void表main（）方法无返回值，java中可以定义多个类，但是只能有一个公共类，main（）方法只能由一个 String【】 args是传递给main（）方法的参数，参数名为args 一个java类中可以由多个方法，也可以没有方法 文件名必须和public修饰的类名保持一致。
path是外部执行的命令 classpath代表类的执行命令 （是字节码执行的） .代表当前命令 ..代表上一级命令
编译源文件格式： javac 类名.java 就可以把源代码变成字节码文件，执行的时候只能执行带由main（）方法的类 。
javac后面可以跟java源程序文件名，文件名可以有多个，还可以用*（可代表多个）和？（代表一个）通配符，只能在编译的时候用。
一个源文件中有多个类，他就生成多个对应的类。
批处理（.bat）
用批处理来编译和执行java文件
set path=（含有编译器何洁时期的bin目录）；
set classpath=源文件目录或字节码文件目录；
javac –d源文件目录或字节码文件目录类名.java
java 类名
pause
pause用来暂停命令
面向对象程序设计入门
1 面向对象思想
用计算机语言表述的事物与实现世界中该食物的本来面目尽量保持一致
2 面向对象的核心概念
一是类 一是对象
类 是对现实世界中某类事物的概念的抽象的表述
对象 现实世界中某类事物的具体存在
他们之间的关系：类是对象模板，对象是类的具体存在
类的两个要素：属性（描述类的外观或特性，也可以说成是用来接收数据，又称为数据）
方法（描述类的行为对属性进行操作的途径，即用于完成类的功能和对属性的初始化，又行为）
public class Person{
private String name;//姓名
private int age;//年龄
private String sex;//性别
private int height;//身高
public void sleep(){
System.out.println("睡了一整天的觉");}
public void eat(){
System.out.println("今天吃了一顿饭，好饿啊！");}
public void run(){
System.out.println("从来没有跑过步，呵呵");}
}
public class TestPerson{
public static void main(String[] args)
{
person p1=new person();//创建了一个对象
p1.sleep();
p1.eat();
p1.run();
}
}
类的设计
1 两个要素
属性（数据）：描述类的外观和特征
方法（行为）：描述类的行为或对属性进行操作的途径
2 modifiers class 类名{
属性定义
方法定义
构造函数定义
}
a modifier（修饰符）：public private protected final abstract static
b 类名必须是名词或者名词短语，每个单词的首字母要大写
c 属性定义(成员变量)： modifier 数据类型 属性名（默认值）
《只有方法实现没有声明的叫游离块》
d 方法定义（成员方法）：modifier 方法返回值类型方法名（形参列表）{
1-N行Java代码
}
形参：方法被调用时，用来接受外部传入的数据的变量。
实参：调用方法时，用来传递给被调用方法的实际的数据。
e 定义了一个类，相当于定义了一种新的引用数据类型
在程序扩充的其他类以基本类中都可以直接使用该类作为一种数据类型进行操作。
在一个Java源文件中可定义多个类，但是只有一个public类，且与原文件名一致。
用同一个类创建的不同对象，他们之间不会受到影响。
构造方法（构造函数）的声明格式： modifier 方法名（参数列表）{
//构造方法体
}
构造方法可重载，不可继承。可调用本类或者父类的构造方法。
具体做法：1 使用this来调用本类的其他构造方法。
2 使用super来调用父类的构造方法。<与普通的super不同，super指其直接父类的构造方法，而不能是间接父类的构造方法。>
3 既不用this也不用super，则编译器会自动加上super()，即调用父类的布袋参数的构造方法。
Java的内存布局
栈：存放基本数据类型和引用数据类型的引用变量.
堆：存放引用数据类型的对象。
引用数据类型数据是以堆，栈的方式存放和管理的，当通过 new 构造函数() 在堆中产生了一个对象后，为了方便程序员显式的控制和操作堆中的这个对象，必须同时在栈中声明这个对象所属的类的类型的引用变量来指向堆中的这个对象。该引用变量的值是堆中这个对象的首地址值，而不是堆中对象的实际值，故称为引用变量<句柄>。
Java内存管理
对于堆中的对象，在程序运行出其作用于之外后，该对象没有任何引用变量指向它，就称为了垃圾，由jvm中的gc在将来的某个时刻从内存中消除。
对象的构造和初始化
作用：对对象的属性进行初始化被对象自己调用《在构造好对象之后》
定义：方法名与类同名。没有返回值类型，方法体重可以有单独的return语句，但不能用return返回一个具体操作数。
《定义一个类是系统会自动提供一个没有参数的构造函数，若定义有参函数，则不提供没有参数的构造函数。》
对象的构造
方式： new 构造函数(参数)
首先。通过jvm构造一个构造函数所属的类的类型的对象，在调用对象的相应的构造函数对对象的属性进行初始化。【在一个类构造微对象之后，类的属性和方法就成为了对象的属性方法，即对象的成员变量和成员方法。】 通过引用变量名，成员的方式进行操作。
类的定义
public class School{
private String name;//名字
private String site;//地址
private int age;//年龄
public School(){
}
public School(String n,String m){
name = n;
site = m;
}
public School(String n,String m,int i){
name = n;
site = m;
age = i;
}
public void show(String n,String s){
name = n;
site = s;
}
public void show(String n,String s,int a){
name = n;
site = s;
age = a;
}
public void run(String a)
{
System.out.println("学校组建三周年了");
System.out.println("得到的值="+a);
}
public void describe(String b)
{
System.out.println("学校坐落在湖南长沙，有四个校区");
public void setName(String c){
name = c;
}
public String getName(){
return name;
}
public void setSite(String b){
site = b;
}
public String getSite(){
return site;
}public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
}
测试与输出
public class TestSchool{
public static void main(String[] args){
System.out.println("------------------**********----------------");
School s6 = new School("zhongnan","yueluqu");
System.out.println(s6.getName());
System.out.println(s6.getSite());
s6.show(s6.getName(),s6.getSite());
System.out.println("------------------**********----------------");
School s7 = new School("zhongnan","yueluqu",5);
System.out.println(s7.getName());
System.out.println(s7.getSite());
System.out.println(s7.getAge());
s7.show(s7.getName(),s7.getSite(),s7.getAge());
}
}
运行 （School s1 = new School("中南大学","岳麓区左家垅",5);）
1 School s1在栈中声明一个引用变量，该引用变量没有占据内存空间。
2 new School("中南大学","岳麓区左家垅",5);在堆中产生一个对象和一个专有的地址。
如果是一个没有参数的构造函数，系统会进行默认初始化。
如果是一个有参数的构造函数，则会进行显示初始化。
将堆中对象的首地址赋值给栈中的引用变量（句柄）。
函数所属的类的类型的对象，在调用对象相应的构造函数对对象的属性进行初始化。 在一个类构造为对象之后，类的属性和方法就成为了对象的属性方法，即对象的成员变量和成员方法。通过引用变量名，成员的方式进行操作。
信息的封装和隐藏
定义一个类时，应该将属性定义为私有的，只有本类可以直接操作，外部其它类不能直接操作，由类自己再定义一些操作者写书型的哦国内共有方法，外部其它类可以通过这个类的共有方法来操作该类的属性。
优点：隐藏了类的实现细节，防止了对数据的未授权访问，保证了数据的安全和一致性。
Java语法
java 注释（对Java源文件起到解释说明作用的一个文档，提高程序可读性）
单行注释：//注释内容
多行注释：/*注释内容*/
文档注释：/**注释内容*/
（jdk提供了一个自己生成工具javadoc，可将public前定义的文档注释生成再文档中，通过javadoc工具将原文件的文档化注释提取到生成的文档中。）
（classpath对javadoc生成文档注释有影响。）
（只能位于属性定义，方法定义以及类定义的前面，注释内容可以被javadoc命令提取并产生api文档。）
java分隔符的组成：“；”（语句结束符，for语句中分割不同成分，也可以放在{}后面）“，”（可以再构造方法和方法中用于分割不同类型名称）“.”（通过引用调用方法）“空格”（增强可读性）“{}”（用于类，构造方法，一般方法）
java标识符：给类和类的成员所起的名称。
规则：必须以字母，数字，下划线和$符为开头，还可以采用中文命名，但是不要使用中文的。
后面可以接上 字母，“—”，“$”，数字。
java 关键字： 用来赋予特定含义的，用作专门用途的单词；java关键字均为小写，TURE,NULL都不是关键字；ture，false不是java关键字；goto和const虽为使用，但是作为一个保留字。
java数据类型：分为基本数据类型（4中整型2中浮点型1种引用数据类型和1中Boolean类型）{只能代表一个数，一个字符，ture和false【Boolean类型】}和引用数据类型 eg：String是引用数据类型（自己定义的类型，通过对象调用）。
基本数据类型：【四类八种】 （只能保存单一的值，又可以称之为简单数据类型）
1 数值型 ：整型（byte，short，int，long【数值后面加一个后缀L】）byte和short 类型主要用于特定场合。如：底层的文件处理或者需要控制占用存储空间量的大数组。
浮点型（float，double，【特殊的浮点型】有：正无穷大（infinity），负无穷大（-infinity）和溢出（NaN）） 很少情况下使用float型，只有在如：需要快速处理单精度数据，或需要存储大量数据时使用。浮点数值不适用于禁止出现舍入误差的金融计算中。Eg：System.our.println(2.0-1.1);结果未0.899999而不是0.9。因为浮点型是采用二进制表示的，而二进制系统无法精确表示分数1/3
2 字符型 char (java 中的char类型用UTF-16编码描述一个代码单元。)
3 Boolean型 值是ture和false 【适用于逻辑运算，用来控制程序的流程控制】
《ture和false不能与整型进行相互转换》
引用数据类型：（可以存储多个数据，只要是同一种类型即可）
类（地址），接口和数组。
【【Integer.toHecString(i); 十六进制】数值有一个前缀Ox】{十六进制中用来表示指数的是p，而不是e}
【【Integer.toOctalString(i); 八进制】数值有一个前缀O】
【【Integer.toBinaryString(i); 二进制】】
【修改过的代码一定要重新编译】
【方法内部定义的属性不需要修饰符】
数据类型间相互转换：将一种数据类型的值赋给另外一种数据类型的变量；
前提是： 1 两种数据类必须兼容
2 源类型取值范围小于目标类型取值范围。
eg：int i= 7；
byte b = 9; // 报错
强制类型转换语法：目标数据类型 目标变量 = （目标数据类型）【源类型值】
Eg: int i= 7;
Byte b = (byte)i; //输出7
<若改7为256，只会输出0，从低位拿起>
变量：《每个变量在java中属于一种类型（byte）》
1 变量名必须是以字母开头的字母或数字序列。
2 变量名中所有的字符都是有意义的，并且大小写敏感。
3 变量名不能为java保留字。
4 变量用于记录数据。分为两部分，变量名和变量值，可以通过变量名得到并修改变量值，在内存中标识变量。
初始化变量：eg：int vocationday = 12；《声明可放在java中的任何位置》
变量及其作用域范围：
局部变量：在方法中或程序块中定义的变量，只在方法体内或程序块内有效。
|
变量按使用范围分为：局部变量（定义在方法内或该方法的参数列表中的变量，该方法中的变量只能被方法使用。在使用前必须初始化。参数列表中的局部变量在调用时初始化。适用范围是：包含该变量的方法）和成员变量（定义的类的内部，方法的外部，为类所公有。适用范围是：整个类。） |
。 2 方法运行才会有内存
Eg：public class Variable{
{
Int k = 10;
}
public int add（int i，int j）{
return i + j + k；
}
}//第二个k没有定义，会报错。
3 所有的变量在使用强必须明确初始化，在使用前必须显式初始化，在方法中被运行时占用内存，方法运行完成之后从内存中自动清除。
引用型变量保存的实际上是对象在内存的地址，称为对象的句柄。
《由于一个对象实体可能被多个变量说引用，在一定意义上就是一个对象有多个别
名，通过一个引用可以改变另一个引用所指向的对象实体的内容。》
对于基本数据类型：java中传递实际数据值。
对于引用数据类型：java中以传递引用变量的方式传递实际的对象值。
方法要修改参数，必须参数是引用类型，例如：数值。
Java中有一种调用叫传值调用，有的叫引用传值调用。
|
方法：描述一个类的行为，功能，操作变量。其他语言中被称为函数或子程序。 方法规则：1 方法不能直接放在源程序中，必须放在类中。2 一个类中可以有多个方法。3 一个类的方法名可以相同，但是参数列表不能相同。4 方法中不能嵌套方法。5 类中的方法只能由该类所创建的对象来调用。6 同一个类中的多个方法可以相互调用。7 用static修饰的方法不能直接调用非static修饰的方法，除非重新定义一个对象，然后在调用，或者将非static的方法定义为static方法。8 一个类中的方法可以直接调用成员变量。 返回值：方法执行完毕返回给调用环境的值。 返回值类型：调用方法时应该返回的返回值的类型。 return：用于终止方法运行，并返回调用的数据。后面不能再有其他的执行的语句。 void语句终止语句是因为有一个什么都不返回的return语句，如果没有的话系统会自动加上一个。 |
|
|
|
代码 |
|
OS |
|
查找main（）方法，启动程序 |
|
本机 |
|
堆
栈
静态区
代码区 |
|
存储代码，且只有一份，还是公用的。 |
|
字符串常量和静态值 |
|
地址和所有局部变量 |
|
New出来的对象 |
|
Static修饰的静态值不能被复制，且其成员变量归类所有。 |
Java引用数据类型
类，数组和接口
1 以对象的类型存在。
2 创建了一个类就是定义了一种新的数据类型。
3 引用数据类型保存的是对象的地址而不是对象本身。
|
写程序的思路 1 看某一个问题有那些类？ 2 看类中有那些属性和方法。 3 看类之间有什么样的关系，这些关系就是类的方法。 4 根据类创建对象，再调用这些方法建立起关系。（完成类的一些功能。）与数据库连接的用Dao
|
|
栈
0x13
8
9
2008 |
|
Year |
|
Month |
|
Day |
|
新对象my |
|
【默认值为0】
2008
9
8
|
|
Year
|
|
Month
|
|
Day
|
|
堆
|
|
堆中产生一个地址0x13，然后赋值给栈中的对象my，即栈中保存堆的地址。 |
当栈中的对象不用时就成为了垃圾，gc会自动回收。
特殊的转移字符
/n 换行 单个换行可以使用
/b 退格 只退一格
/r 回车 回车单独用不可以，必须和换行一起用
/t 制表符 tab
// 反斜杠
/’ 单引号
/’’双引号
运算符
1 +（即可以作为算术运算符也可以作为字符串String类型的相连
，当字符串在前面的时候+代表相连，反之代表算术运算+号）
- * / 表示加减乘除
当/运算的两个操作数都是整数时，表整数除法，否则，表浮点除法。
整数的求余操作（取摸）用%表示。
%号可对整型浮点型数据求余
10%3.5 = 3.0
|
Eg：某人骑车 我追我女朋友，我女朋友追车。 我去银行存钱。 我管理38班的学生。 我骑车去银行存钱。 |
-10%-3.5 = -3.0
【被模数的正负决定结果的正负，模数的负号忽略不计。】
2 自加(++)自减(--)运算符
<由于++和—改变了变量的值，所以其操作数不能是数值。>
Eg：int n = 12；
n++;//先运算后赋值
++m;//先赋值后运算
3 关系运算符与Boolean运算符
【关系运算符和Boolean运算符一起被用，作为控制语句的判断条件。】【操作的是Boolean型】
==检测是否相等，！=检测是否相等。
<,>,<=，>=【他们之间不能有空格】 和instanceof
&&(简洁与)【当同时是ture时才是ture】
||(简洁或)【当同时是false时才是false】
!(非)
|（或）
&（与）
其中&&和||是按“短路”方式求值，如果第一个操作数已能确定值，第二个就不必计算了。
Eg：a1 && a2;如果a1是false，则结果不可能为true。
三元运算符 ？
Eg：condition？a1：a2；
当true时计算a1，否则计算a2.【条件运算符可以嵌套】
4 位运算符与移位运算符【补码:负数为源码取反加1，正数就直接是补码】【操作二进制数】
&(按位与) 【如果两位都为1，则为1；否则为0】
|(按位或) 【只要一个为1就是1】
^(异或) 【脱字符，当两者相同时为0，相异时为1】
~(非{取反运算符})，
<<(无符号左移)
>>(右移)【移到右端的低位被舍弃，最高位移入原来高位的值。】
>>>（无符号右移）【和右移的不同点是：最高位补0即可。】
{a >> b 等价于 a/2^b; a<<b 等价与a*2^b. }
对int类型的值移动，对移位数b%32
对long类型的值移动，对移位数b%64
浮点类型不进行移位运算
这些运算符在位模式下工作。Eg：如果n是一个整型变量，并且用二进制表示的n从右数第四位起为1，那么int fourthBitFromRight = (n&8)/8; 返回1；否则是0.通过使用2的幂次方和&运算可以将其他位屏蔽掉，而只保留其中的某一位。
&和|运算符应用于布尔值，得到的结果也是布尔值。这两个运算符与&&和||的运算很相似，只是不按“短路“方式进行计算。即在得到计算之前，一定要计算两个操作数的值。
对于int类型的a>>b，系统会先执行b%32，计算结果才是真正的移位数。Long 和float也是一样。即：若低于int类型的操作数，系统会将其先变为int类型再移位。
5 数学函数与常量
计算平方根用sqrt方法： double x = 4;
double y = Math.sqrt(x);//Math.在jdk5.0版本后可以省略
System.out.println(y);//prints 2.0
println方法操作一个定义在System类中的System.out对象的调用。
而Math类中的sqrt方法操作的不是对象，这样的方法称为静态方法。
double y = pow(x,a);//幂运算
sin,cos,tan,atan,atan2都是三角函数。
指数，对数函数：exp,log
表PI和E的是PI和E
6 数值类型之间的转换
|
byte |
|
short |
|
int |
|
char |
|
long |
|
float |
|
double |
|
无精度损失 |
|
可能有精度损失 |
7 强制类型转换（cast）
语法格式：eg：double x = 9.997;
int n = (int)x;
<强制类型转换将通过截断小数部分来把一个浮点型转换为整型。>
当对浮点数进行舍入运算得到的最接近的整数时，用round()方法。
不能在boolean类型与任何数据类型之间进行强制类型转换。也可以转换，需要用条件表达式：b?1:0;
8 括号与运算符级别
先用括号里面的，用一级别运算符按照从左到右的次序进行计算。
9 枚举类型<当变量的取值仅在一个有限的集合内。>
Eg：enum Size{SMALL,MEDIUM,LARGE,EXTRA_LARGE};
现在，可声明这样一种类型的变量。
Size z = Size.MEDIUM;
字符串：<从概念上讲，Java字符串就是Unicode字符序列>
Eg：串“java/u2122” 由五个Unicode字符 j a v a 和 TM 组成。
<Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类String。>
1 代码点与代码单元 <Java字符串由char值序列组成。>
Length 方法将返回采用UTF-16编码表示的给定字符串所需要的代码单元数量。
Eg：String greeting = “Hello!”;
Int n = greeting.length();//is 6
如：int cpcount = greeting.codePointCount(0,greeting.length())
Char first = greeting.charAt(0);//first is ‘H’
2 子串
String类的 subString方法可以从一个较大的字符串提供一个方法。
如： String greeting = “Hello”;
String s = greeting.subString(0,3);//创建了一个又字符Hel组成的字符串
subString 方法有点：容易计算子串中代码单元的适量。即由b-a个代码单元。
3 字符串编辑：
greeting = greeting.subString(0,3)+”p!”;//输出Help！
<由于不能修改Java字符串的字符，所以在Java文档中将String类对象称为不可变字符串>
不可变字符串优点：编译器可将字符串共享。
4 拼接
<使用+号连接两个字符串。>
如：String expletive = “Expletive”;
String PG13 = “deleted”;
String message = expletive+PG13;
5 检测字符串是否相等 <使用equals方法检测>
s.equals(t);//s , t 可以是字符串变量，也可以是字符串常量。
Eg：”Hello”.equals(greeting);是合法的。
“Hello”.equals(IgnoreCase(“Hello”));//不区分大小写。
java.util.Scanner
Scanner s= new Scanner(System.in);
String name= s.nextLine();
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
