java note.doc

java中的变量名 不能以数字开头，可以下划线，$符号，字母开头

java中的数据类型------一.原生数据类型
1.整型 int（32位）
2.字节 byte （-128~127 之间的整数）
3.短整型 short （16位）
4.长整型 long （64位）
5.单精度浮点型 float 浮点型指的就是 小数（也叫做实数）比如1.2
6.双精度浮点型 double （双精度浮点型比单精度浮点型 表示的数据范围大）
7.字符型 char （单个字符表示，例如字母 a，用单引号 例如char a = 'B'）
8.布尔类型 boolean （只有两种值，true 和 false）

***Java中的所有浮点类型默认情况下都是 double
强制类型转换（类型 变量 = （类型）变量值）
***变量在使用前一定要赋值；变量必须要申明其类型才能使用；遍历了在使用前一定要定义，并且只能定义一次

----------------------二.引用类型

注释 java中3种注释
1.单行注释 "//"之后均为注释
2.多行注释 "/*" 开头，"*/"结束 之间的均为注释 （多行注释不能嵌套）
3.另一种多行注释，用于产生java doc帮助文档的，（"/**"开头，"*/"结束）

java 运算符
1.当有若干个变量参与运算时，结果类型为这些变量中表示范围最大的变量类型
若 参与的变量中，类型有整型，有单精度浮点型，双精度浮点型，结果为double

2.int a = 1； int b = 2
double e = (double)a/b 强制类型转换~ ~（注意a仍然是整型）

3.取模运算符------%
取模的符号永远与被除数的符号相同
例如： int a = -5
int b = 3
int c = a % b 取模的结果为 -2

~第五讲 运算符 --续
1.关系型运算符： 大于；小于；等于；不等于（！=）；大于等于；小于等于；
关系型运算符的运算结果为boolean型的

2.逻辑运算符
a.逻辑与 && 只有两边运算均为真 才为真
b.逻辑或 || 只有两边运算均为假 才为假

3.关于逻辑运算符的短路特性
a.逻辑与 第一个操作数为 false，结果必定为false，此情况下将不会执行逻辑与后面的运算
发生短路
b.逻辑或 第一个操作数为 true，结果必定为true，此情况下将不会执行逻辑与后面的运算
发生短路

4.逻辑运算的自增自减
a = a + 1 // a+ = 1 // a++(自增1可以这样写）
~~~~~ a++ 和 ++a 的区别
例如 int a = 3;
int b = a++; 这段中将a的值先赋给b，然后a自增1；所以结果为a=4，b=3

例如 int a = 3;
int b = ++a; 这段中a先自增1，然后将a的值赋给b，所以结果a=4，b=4

第六讲 流程控制语句
1.条件运算符（三元表达式），其形式为：
type d = a?b:c 如果a为真，将b赋值给d，否则将c赋值给d

2.if的用法
~~a. if （布尔表达式）
{
执行的代码
}

~~b. if （布尔表达式）
{
执行的代码
}
else
{
执行的代码
}

~~c. if（布尔表达式）
{
执行的代码
}
else if
{
执行的代码
}
else
{
执行的代码
}

3.switch语句 -------------------（目前内容，只能这4种）byte，int，char，short

switch（变量）
{
case 常量1：
//待执行的代码
break；
case 常量2：
//待执行的代码
break；
case 常量3：
//待执行的代码
break；
default：
//待执行的代码
}-----------------------------------------虽然case语句中的break是可选的，但在绝大多数情况下，不加break
程序逻辑会出现错误

第七讲

java中的循环控制语句一共有 三种（while，do while以及for循环）

1.while循环，形式为：
while（布尔表达式）
{
//待执行的代码
}

2.do while循环，形式为：
do
{
//待执行的代码
}
while（布尔表达式）； -------------while 与 do while之间的区别：
如果布尔表达式第一次判断为false，则while循环一次不循环；
do while循环则会执行一次；

3.for循环（使用最多的一种），形式：
for（变量初始化;条件判断;步进）
{
//待执行的代码
}

for循环的执行过程
1）执行变量的初始化
2）执行条件判断，如果条件判断为假，那么退出for循环，开始执行循环后面的代码；
如果条件判断为真，那么执行for循环里面的代码
3）执行步进
4）重复步骤2

-------------------------------------------------------------------------------------------------------------------------------------------

第八讲 ------理解面向对象程序设计

1. break语句 （经常用在循环语句中，跳出循环，执行之后的语句）

2.continue语句 （经常用在循环语句中，用于跳出本次循环，开始下一次循环的执行）

3.面向对象程序设计（Object Oriented Programming OOP）
什么是面向对象？ 在面向对象中有两个重要概念------类（class） 和 对象（object）
--------类：是一种抽象的概念；其中包含了数据（通常名词表示）以及对数据的操纵（通常用动词表示）
比如说；人就是抽象的概念（人具有姓名，年龄等数据；以及吃饭，跑步等操纵数据的动作）

--------对象：对象是一种具体的概念，是类的具体表示方式；例如人这个类，张三，李四等具体的人就是对象~ ~

4.类所包含的内容
a）数据：在类中称作属性（或者成员变量）---Property or Attribute（Member Variable）

b）对数据的操纵在类中称作方法-------Method

第九讲------------------------------封装
1. 面向对象程序设计的三大基本特征：继承，封装，多态

2．封装：类包含了数据与方法，将数据与方法放在一个类中就构成了封装
3.如何定义类
修饰符 class 类的名字
{
//类的内容（包含属性和方法）
}

4.如何定义方法？
修饰符 返回类型 方法名称（[参数 1，参数 2。。。]）
{
//方法体
}
5. main 方法是整个java程序的入口点，如果类的定义中没有main方法，则程序无法执行
方法定义不能嵌套（不能在一个方法中定义另一个方法）

6.关于方法的执行，首先定义方法，接下来就可以使用方法（调用方法），当方法调用
完毕后，方法可以返回值，方法到底是否返回值是由方法的定义决定的

7.如何生成对象？通过类来生成对象（通常使用new 关键字来生成对象）
Public class person
{

}
类名 变量名 = new 类名（）-------注意有括号
person person1 = new person（）

8.方法调用类需要通过对象来完成，方法调用的形式是：
对象变量 方法名（[参数值1，参数值2，参数值3.。。。]）

9.关于方法的注意事项
1）在方法定义中，方法的返回类型与return后面的变量或常量类型保持一致

2）在方法调用时，给方法传递的参数需要与方法定义时的参数保持一致（参数个数保持一致，参数类型保持一致）
3）方法定义时的返回类型与接受方法返回值的变量类型保持一致

11.public int add(int a,int b)
{
return a+b；
}
方法定义时的参数 形式参数
方法调用时所赋予的具体值叫实际参数

12.关键字 void表示方法不返回值
13.如果方法不返回值，那么声明方法的时候使用void关键字，在方法定义中可以有两种情况不返回值
1） 不使用return语句；
2）使用return，return后面没有任何值或者变量；return后面只有一个分号，表示退出方法
Return----------------------------相关例子

第十讲 面向对象之封装续

1. 类中的属性（property）又叫做成员变量（member variable）
2. 对象（object）又叫做实例（interface），生成一个对象的过程叫做类的实例化
3. 命名约定
A） 类：首字母要大写，如果类名由多个单词构成，则每个单词的首字母都需要大写，
并且中间不使用任何的连接符，比如Person类，MemberTest类
B） 方法：首字母小写，如果一个方法有多个单词构成，则第一个单词的所有字母
都小写，从第二个单词开始，每个单词的首字母大写，比如add，addThreeInt
C）属性：命名约定与方法相同，比如age，ageOfPerson

4.属性需要定义在类中，又叫成员变量，而定义在方法中的变量叫局部变量
5.如何定义属性？
Public class Person
{
修饰符 类型 属性名称
}
如何使用属性？与方法一样，使用运算符，首先需要生产类的实例，然后使用实例+“.”
的方式来使用属性

6.局部变量使用前必须要申明并赋值，成员变量使用前必须要声明，但可以不赋初值
7.成员变量与局部变量的联系与区别：
A）无论是成员变量还是局部变量，使用前都需要声明（定义）
B） 对于局部变量来说，使用前必须要初始化，对于成员变量来说，使用前可以不初始化
如果没有初始化成员变量就开始使用，那么每个类型的成员变量都有一个默认的初始值
（byte，short，int，long 类型的初始值为0）；（float，double类型初始值为0.0）；
char类型的初始值 ‘\u0000’
Boolean类型的初始值 为 false
8.引用类型（reference type），引用类型是用在对象上的，一个对象可以被多个引用所指向，
但同一时刻，每一个引用只能指向唯一的一个对象，如果一个对象被多个引用指向，
那么无论哪个引用对象的属性进行了修改，都会反映到其他的引用当中

第十一讲 封装----------------------续二

1. 如果一个类包含了属性与方法，那么该类的每一个对象都具有自己的属性，但无论一个
类有多少个对象，这些对象共享同一个方法
2. 关于方法参数传递的总结，对于java中的方法参数传递，无论传递的是原生数据类型还是引用类型，统一是传值（pass by value）
3. 什么类型的引用就能指向什么类型的对象，比如people类型的引用就能指向people类型的对象，但不能指向student类型的对象，比如：
People people = new People（）；// 正确
People people = new Student（）；// 错误

4. 构造方法（）：构造方法用于完成对象属性的初始化工作，构造方法的特点：
a) 构造方法的名字必须与类名完全一致（包括大小写）
b) 构造方法没有返回值，连void也不能出现
c) 如果在定义一个类的时候，没有为类声明构造方法，那么java编译器会自动为类
添加一个没有参数且方法体为空的构造方法，称作默认构造方法
d) 如果在定义一个类的时候，为类声明了构造方法，那么java编译器就不会再为类添加构造方法
e) 不能显式通用类的构造方法，构造方法通常是通过new关键字隐式调用

5. new 关键字在生成对象时完成了三件事情
a) 为对象开辟内存空间
b) 调用类的构造方法
c) 将生成的对象的地址返回

6. 默认的构造方法：构造方法没有参数且方法体为空

7. 使用new来生成对象的时候，后面的小括号（）表示的构造方法的参数列表，如果构造方法不接收参数，那么小括号中的内容为空，如果构造方法接收参数，那么小括号中的实际参数就需要与构造方法定义中的形式参数保持一致（参数数量一致；参数类型一致；按照顺序逐一赋值）

~~~~~~~~~~~~~~~~~~~Review~~~~~~~~~~~~~~~~~~~~~

break 跳出的是其所在的循环---------------------------------实例
方法重载，表示两个或多个方法名字相同，但方法的参数不同，参数不同有两层含义：
1)参数个数不同， 2）参数类型不同， 注意：方法的返回值对重载没有任何影响

构造方法重载：只需要看参数即可，如果想在一个构造方法中调用另一个构造方法，那么可以使用this（）的方式调用，this（）括号中的参数表示目标构造方法的参数
this() 必须要作为构造方法的第一条语句，换句话说，this（）之前不能有任何可执行的代码

Java SE Lesson1
7.继承
java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类【基类】，
继承的类叫做子类），java中的继承使用extends 关键字

8.当生成子类对象的时候，java默认首先调用父类的不带参数的构造方法，然后执行
该构造方法，生成父类的对象，接下来，再去调用子类的构造方法，生成子类的对象。

9.super 关键字：super表示对父类对象的引用

10.如果子类使用super（）显式调用父类的某个构造方法，那么在执行的时候就会寻找与super（）所对应的构造方法而不会再去寻找父类的不带参数的构造方法。与this（）一样

11.关于继承的3点：
a）父类有的，子类也有
b）父类没有的，子类也可以增加
c）父类有的，子类可以改变

12.关于继承的注意事项：
1）构造方法不能被继承
2）方法和属性可以被继承
3）子类的构造方法隐式的调用父类的不带参数的构造方法
4）当父类没有不带参数的构造方法时，子类需要使用super关键字显式的调用父类的
构造方法，super指的是对父类的引用
5）super关键字必须是构造方法中的第一行语句

13.方法重写：又叫做覆写，子类与父类的方法返回类型一样，方法名称一样，参数一样，
这样我们说子类与父类的方法构成了重写关系

14.方法重写与重载之间的关系：重载发生在同一个类内部的两个或多个方法
重写发生在父类与子类之间（一定伴随继承发生的）

15.当两个方法形成重写关系时，可以在子类方法中通过super.run（）形式调用父类的run()方法，其中super.run()不必放在第一行语句，因为此时父类对象已经构造完毕，先调用父类的run()方法还是先调用子类的run()方法是根据程序的逻辑决定的

16. object类是java中所有类的直接或间接父类

17. 多态
我们说子类就是父类（rose是花，男人是人），因此多态的意思就是：父类型的引用可以直接指向子类的对象

Java SE Lesson2
1.一共有两种类型的强制类型转换：
a）向上类型转换（upcast）；比如说将Cat类型转换为Animal类型，即将子类型转换为父类型，对于向上类型转换，不需要显式调用
b）向下类型转换（downcast）；比如将Animal类型转换为Cat类型，即将父类型转换为子类型，对于向下类型转换，必须要显式指定（必须要使用强制类型转换）

2.抽象类（abstract class）
使用了abstract关键字所修饰的类叫做抽象类，抽象类无法实例化，即不能new出来一个抽象类的对象

3.抽象方法（abstract method）
使用abstract关键字修饰的方法叫做抽象方法
抽象方法需要定义在方法类中；相对对于抽象方法，之前所定义的方法叫做具体方法（有声名，有实现）；抽象方法有声明，无实现

4.如果一个类包含了抽象方法，那么这个类一定是抽象类

5.一个类是抽象类，那么该类可以包含具体方法

6.{{ 如果一个类中包含了抽象方法，那么这个类一定要声明成abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法 }}

7.无论何种情况，只要一个类是抽象类，那么这个类就无法实例化

8.接口（interface）：接口的地位等同于class，接口中的所有方法都是抽象方法。
在声明接口中的方法时，可以不包括abstract 关键字

9.可以将接口看作是特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具体方法）

10.类可以实现接口，实现使用关键字implements表示，代表某个类实现了某个接口
11.一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是个抽象类，那么就无需实现接口中的方法了。

12.java是单继承的，也就是说某个类只能有唯一一个父类；一个类可以实现多个接口，多个接口间使用逗号分隔。

13.多态：父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。

14. static关键字用来修饰属性，也可以用于修饰方法，还可以用于修饰类

15.static修饰属性：无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之方式变化。如果一个成员变量是static的，那么我们可以通过类名.成员变量名的方式来使用它。

16.static 修饰方法：叫做静态方法。对于静态方法来说，可以使用类名.方法名的方式来访问。

17.final关键字：可以修饰属性，方法，类。
18.final修饰类：当一个类被final所修饰时，表示该类是一个终态，即不能被继承。

19.final修饰方法：当一个方法被final修饰时，表示该方法是一个终态方法，即不能被重写

20.final修饰属性，当一个属性被final所修饰时，表示该属性不能被改写

21.当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化（比如说不能从10变成20）；如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。

22.对于final类型成员变量，一般来说有两种赋初值方式：
a） 在声明final类型的成员变量时就赋上初值
b） 在声明final类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋上初值

23.不能再静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量，可以在非静态方法中访问静态的成员变量。

总结：静态的只能访问静态的；非静态的可以访问一切。
不能再静态方法中使用this关键字

JavaSE lesson3
1.接口中所声明的方法都是抽象方法，接口中的方法都是public的

2.接口中也可以定义成员变量，接口中的成员变量都是public，final，static的

3.包（package）：用于将完成不同功能的类分门别类，放在不同的目录下。包的命名规则：将公司域名反转作为包名。例如： – com.baidu. 对于包名每个字母都要小写。如果定义类的时候没有使用package，那么java认为我们使用了默认包（default package）。

4.使用编译参数 –d，方式为javac -d，源文件.java，这样在编译后，编译器会自动帮助我们建立好包。且源文件已经编译好了

5.导入（import），将使用package分离的各个类导入回来，让编译器能够找到所需要的类

6.import的语法：import com.baidu.PackageTest;

7.import com.baidu.* ,表示导入com.baidu包下面所有类（但是com.aa.bb*并不会导入aa.bb.cc包下面的类，这时需要这样写：
import aa.bb.*;
import aa.bb.cc.*;

8.关于package、import、class的顺序问题：
a) 首先需要定义包，可选
b) 接下来使用import进行导入，可选
c) 然后才是class或interface的定义

9.如果两个类在同一个包下面，那么则不需要导入，直接使用即可

10.访问修饰符
1) public（公共的）：被public所修饰的属性和方法可以被所有类访问
2）protected（受保护的）：
3）private（私有的）：被private所属性和方法只能在该类内部使用
4）默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用

11.instanceof：
判断某个对象是否是某个类的实例。语法形式：引用名 instanceof 类名（接口名），返回一个boolean值。

12.相等性的比较（==）
1）对于原生数据类型来说，比较的是左右两边的值是否相等
2）对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者说左右两边的引用地址是否相同
13. java.lang.Object类
java.lang包在使用的时候无需显式导入，编译时由编译器自动帮助导入

14. API 应用编程接口 Application Programming Interface

15.当打印时，实际上会打印出引用所指对象的toString()方法的返回值，因为每个类都直接或间接地继承自Object，而Object类中定义了toString()，因此每个类都有toString()这个方法。

△16. equals()方法，该方法定义在Object类当中，因此java中的每个类都具有该方法，对于object类的equals()方法来说，它是判断调用equals()方法的引用与传进来的引用是否一致，即这两个引用是否指向的是同一个对象。对于object类的equals()方法来说，它等价于==

△17.对于String类的equals()方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。

△18.对于String对象的相等性判断来说，请使用equals()方法，而不要使用 ==。（29讲）

19.