学
习
笔
记
PeterChing 编写
马士兵 Java 系列
0201
标识符 关键字 数据类型
标示符:
一:凡是自己可以取名字的地方都叫做标示符
二:标示符应该由字母,下划线,美元符,数字组成。其中,应该由字母,下划线,美元符
开头。即不可以用数字开头。
JAVA 常量:
一:用 final 关键字标示的地方
二:整型常量 123;实型常量 3.14;字符常量'a';逻辑常量 TRUE、FALSE;字符串常量“hello”。
注意字符常量与字符串常量的区别。字符常量用单引号,而字符串常量用双引号。
JAVA 变量:变量从本质上来讲,其实是内存中的一小块区域。因此,每一个变量使用前必
须先声明,然后必须进行赋值(填充内容),才可以使用。
注意:double d1,d2,d3=0.234;表示 d3=0.234 而不是 d1,d2,d3 都等于 0.234
程序执行过程
1:程序 load 到内存中
2:操作系统找到 main 函数,开始执行程序
3:执行过程中的内存管理
(1)code segment 用来存放代码。也就是说 load 后整个程序放在了此区域。
(2)data segment 用来存放静态变量和字符串常量
(3)stack 用来存放局部变量
(4)heap 用来动态生成内存,也就相当于 new 出来的东西放在此区域。
就是说程序首先(也就是编译时)load 到 code segment 后,在程序真正执行时此区域就会和
其他三个区域发生关系。因为程序执行需要分配变量等等。可以这么理解:没有建立对象,
程序只是作为代码存在 code segment,没有什么实际意义的。只有在建立对象,在运行时 code
segment 才会和其他三个区域发生关系,程序也才有了实际意义
JAVA 变量的分类
按照声明的位置划分:
局部变量:方法或语句块内部定义的变量
方法的参数叫局部变量。所以在方法体内声明的,包括方法的参数叫做局部变量
成员变量:方法外部、类的内部定义的变量
在方法体外,类体内之间声明的叫成员变量
按照所属的数据类型划分:
基本数据类型变量:
1 数值型,它包括整数类型(byte,short,Int,long)和浮点型(float,double)
2 字符型(char)
3 布尔型(boolean)
引用数据类型变量:
1 类(class)
2 接口(interface)
3 数组
JAVA 基本数据类型
JAVA 中定义了 4 类 8 种基本数据类型
逻辑型:boolean(只可以取 TRUE,FALSE)
文本型:char 也就是字符型
整数型:byte,short,Int,long
浮点型:float,double
JAVA 用 Unicode 编码,每个字符占两个字节,所以可以用十六进制编码形式表示,Unicode
是全球语言的统一编码
0202
整数类型:byte 占 1 个字节,short 占 2 个字节,int 占 4 个字节,long 占 8 个字节。
当声明为 long 时后面要加 l 或者 L 否则默认为 int 了。比如 long c=5555L 必须加 L 否则出错
浮点类型:float 占 4 个字节,double 占 8 个字节。但是要注意浮点类型默认的是 double 类
型。所以若要声明为浮点类型,则要加 f 或者 F。例如:double d=123.2;正确 float f=12.3f
必须加 f 否则出错
0203
基本数据类型的转换
boolean 类型不可以转换为其他的数据类型,这点与 C++不一样。
整形,字符型,浮点型的数据在混合运算时相互转换,转换的原则:
1、容量小的自动转换为容量大的数据类型。容量由小到大的排列:
byte ,short,char,->int->long->float->double
2、byte ,short,char 之间不会相互转换,他们三者在计算时首先转换为 int 类型
容量大的要转换为容量小的数据类型,需要强制转换。但是可能造成精度降低或者溢出。
强制转换的格式:在数据前加一个()在括号里写需要强制转换成为的类型。
在有多种类型的数据混合运算时,系统首先自动将所以得数据转换成为容量最大的那一种数
据类型,然后进行运算
0206
a+=b 等效于 a=a+b
a*=b 等效于 a=a*b
“+”预算符两侧的操作数只要有一个是字符串(string)类型,系统会自动将
另外的一个操作数转换为字符串后在进行连接。例如:
int c=23;
system.out.println("c="+c);//c 成为字符串还是 12
当进行打印时,无论任何类型,都自动转换为字符串再进行打印
x?y:z 当 x 的表达式为真时则整个表达式的结果为 y,否则为 z
0210
break 语句用于终止某个语句块的执行。若是用在循环语句中,可以强制退出循环。
;分号表示空语句 在 for 语句后不要写分号!!!
continue 语句用在循环语句中,用于终止某次循环过程,跳过循环体中 continue 语句下面未
执行的循环,开始下一次循环过程
0212
switch()括号里面只可以探测 int 类型 但是记住 short,byte,char 也可以的
因为他们可以转换成为 int
switch 多于 break 连用,防止穿透
0213
方法要点:
形式参数
实参
返回值
返回值类型
public static void m1(){
}//方法 m1()返回值为空
public static void m2(int i){
}//方法 m2()返回值为空,但是它有一个形参而且是 int 类型的
public static int m4(int i,int j){
}方法 m4()返回值为 int 类型,而且有两个 int 类型的形参
可以这么相像:1、形式参数相当于进料口,返回类型相当于出料口 2、实参和形参相匹配
JAVA 中进行函数调用中传递函数时,遵循值传递的原则:(很重要!!!)
1、基本数据传递的是该数据值本身
2、引用类型传递的是对对象的引用而不是对象本身
0301
以开车去新疆为例:
面向过程的设计思想,以车为中心
面向对象的设计思想,以我为中心
在面向对象时,车怎么开动去新疆,车本身最了解。因为它知道自己的内部结构,工作原理。
我们在定义一个东西的时候很难完整的写出这个类的抽象的定义。比如在定义瓶子的时候,
你若描述可以装水的是瓶子,我们可以这样反驳:装米的缸子也可以装水;你若定义有盖子
的是瓶子,我们可以反驳:做饭的锅也有盖子……诸如此类的问题。
其实,这个问题就是一般和特殊的哲学关系——一般中蕴含着特殊。要不然都一样了,就是
一个东西啦!你下了一个抽象的定义,我总是可以找到一个东西满足你描述的所有条件,但
是它却不是你要的这个东西。所以我们在定义一个类时,只是包括了一般的具有共同代表性
的重要的方法和属性,不太可能面面俱到。
其实就是一个思维的问题。我们不太可能定义什么是瓶子(抽象),但是我们可以判断一个
东西是不是瓶子(具体)。这也就是说我们开始认识事物时由具体到抽象。在看到许多瓶子
以后,我们的思维里出现了一个瓶子的抽象类。比如在超市的货架上,摆着好多的瓶子,他
们的共同属性是可以装溶液,倒出溶液;有盖子,有容积。但是它们的具体实际可能有差别
别如:容积大小,耐热程度,颜色,材质……
抽象出一个类从两方面:静态(属性)和动态(方法)
面向对象时尽可能运用人类的自然思维方式
属性和成员变量时一回事
类和类之间的关系
关联关系:两者之间有一点关系,但是不紧密
继承关系:能这样描述"XX 是一种 XX"的就是继承,比如老师是人
聚合关系:整体和部分的关系。
聚合关系中的聚集:也就是“XX 是 XX 的一部分”但是这种关系比较松散
聚合关系中的组合:密不可分的关系,必不可少的关系。
实现关系
多态关系
0302
必须先定义一个类,才再有对象
必须先定义方法,才可以调用它
我们要写一个程序,先写出来一个类来
public class Dog{
int furColor;
float height;
float weight;
void catchMouse(Mouse m){//抓耗子的方法.void 表示这个方法的返回值是空
m.scream();
}
//具体的方法
//耗子发出叫声
public static void main(String[] args){
Dog d=new Dog();
Mouse m=new Mouse();
d.catchMouse(m);
}
}
0303
成员变量可以是基本类型,也可以是引用类型
成员变量在定义时可以初始化,也可以不初始化则 JAVA 使用默认的值对其初始化
成员变量作用域在整个类体
JAVA 中除了基本类型之外的变量类型都称之为引用类型
JAVA 中的对象是通过引用对其进行操作的
如果成员变量的是引用类型,若不对其初始化,那么它被默认为 NULL
成员变量和局部变量的重要区别!!!
成员变量不具体给值时默认为 0;但是局部变量必须先声明,再赋值,然后引用,否则错误
class C{
int i;
int j;
……main……{
C c1=new C ();
C c2=new C ();
}
}
这段代码在执行前都是存放在 code segment 段
区分内存中的类和对象
1、类是静态的,在代码区(也就是说上面这段代码在执行前都是存放在 code segment 段)
2、对象时 new 出来的,位于堆内存,类的每个成员变量在不同的对象中都有不同的值(除
了静态变量),而方法只有一份执行的时候才会占用内存。可以这么理解:没有建立对象,
这个程序只是作为代码存在 code segment,没有什么实际意义的。只有在建立对象,在运行
时 code segment 才会和其他三个区域发生关系,从而有了实际意义
基础类型只占 1 处内存,但是其他的要占 2 处
JAVA 中的对象是通过其引用进行操作的
局部变量(如 c1,c2)放在了 stack 段 而 new 出来的对象放在了 heap 段;指针由前者指向后
者,这就是引用!!!
堆内存是用来动态分配内存空间的,所以 new 出来的对象是放在堆内存的
C c1=new C ();
在栈里面分配了一小块内存(编译后存在)叫 c1 .这一小块内存里面有一个指针(也就是一个
地址)指向堆里的一块较大的内存(执行时动态分配)此堆里的较大块的内存才真正地存储
这个对象 C1,C1 有自己的 i 和 j(因为 i 和 j 是成员变量,即是一个类的静态属性。它的每一
个实例对象当然有这两个属性)
与此类似,C2 也有自己的 i 和 j .所以 c1、c2 相当于此对象的引用
注意要理解 int i,int j 的存放。在这段代码执行前他们都是存放在 code segment 段,但是在执
行后堆内存的对象 C1,C2 都有自己的 i 和 j
0304
构造方法
1、使用 new+构造方法创建一个新的对象
2、构造函数与类同名且没有返回值,也不是返回值为空
3、当不写时,系统会自动生成一个空的构造函数:类名()
所以我们平时多半时候并没有写构造函数,但是也不报错就是因为系统自动生成了:类名()。
其实我们经常写的比如 Dog d=new Dog();它的实质就是左边的 Dog 是类名,右边的 Dog 是
构造函数。空的构造函数,就是表明它的构造函数的参数为空。
public class Person{
int id;
int age=20;
Person(int_id,int_age){
id=_id;
age=_age;
}
public static void main(String [ ] args){
Person tom=new Person(1,25) ; //第一个 Person 指的是类名,第二个 Person 指的是构造函数!
}
}
当调用一个方法时,方法里的变量以及方法的参数都是局部变量!!!
所以通过 new+构造方法时调用了构造方法。这个时候在 stack 中分配了 tom 和 _id,_age 三
个小内存块。切记!当一个方法调用完成以后,在 stack 中为这个方法分配的所以空间会释
放消失。所以当建立起这个对象后,栈中构造函数的 _id,_age 会被回收,但 tom 还在。但
是 Heap 中的实际的对象会保留下来
构造方法就是把自己构造成一个新的对象
new 实际上是调用了构造方法
注意构造函数的内存解析
“方法执行完以后,局部变量(stack 中)就没了”也就是说:吃饭以后,收筷子。但是新
建的这个对象的引用还存在 stack 中,也就是说 tom 还在但是-id 和-age 已经不在了。所以
通过控制 tom 来控制-id 和-age
0307
class BirthDate {
private int day;
private int month;
private int year;
public BirthDate(int d, int m, int y) { //构造方法
day = d;
month = m;
year = y;
}
public void setDay(int d) {
day = d;
}
public void setMonth(int m) {
month = m;
}
public void setYear(int y) {
year = y;
}
public int getDay() { //int 表示返回值类型
return day;
}