java 学习笔记之二

位运算

Lesson2A

一、计算机中数据的表示方法

计算机是一种 电子设备 ，由复杂的 电子元器件 组合而成，一个电子元器件 有带电和 不带电 两种状态，通常我们将 带电状态 表示为 数值1，不带电状态 表示为 数值0，多个这样的 元器件 的组合可以表示更多状态，也就是可以表示更多的数据，如 000表示0，001表示1，010表示2，011表示3，依此类推，111表示7，一个元器件 可表示 一位（bit）数据，这种表示数据的方式就叫 二进制。在实际的电子设备中，我们将 8个 这样的 元器件 形成一个单元，这样的单元叫 一个字节（byte），一个字节能表示多少个数呢？表示数值的范围是0-255。

一个字节由8个二进位组成，其中最右边的一位称为“最低有效位”或“最低位”，最左边的一位称为“最高有效位”或“最高位”。每一个二进位的值是0或1。

二进制计数的缺点: 书写太长，容易出错，一般计算机的数据位数都是4的整数倍，所以，在计算机里通常采用 16进制计数法 。用数字可以表示各种信息，计算机里只有数值，当你在内存中看到一个数值时，这个数值可能代表各种意义，生活中的数值也可以代表其他意义，如1234可以代表 密码，存款额，电报信息，根据上下线索，我们就能够知道这数值代表的意义。

原码、反码和补码

1. 原码

将 最高位 作为 符号位 （以0代表正，1代表负），其余各位 代表数值本身的绝对值（以二进制表示）。为了简单起见，我们用1个字节来表示一个整数。

+7的原码为： 00000111

-7的原码为： 10000111

问题：

+0的原码为： 00000000

-0的原码为： 10000000

2. 反码

一个数如果为正，则它的反码与原码相同；

一个数如果为负，则符号位为1，其余各位 是对原码取反。

为了简单起见，我们用1个字节来表示一个整数。

+7的反码为： 00000111

-7的反码为： 11111000

问题：

+0的反码为： 00000000

-0的反码为： 11111111

3. 补码 利用溢出，我们可以将减法变成加法。

对于十进制数，如果从9得到结果5，可以用减法：

9-4=5

因为4+6=10，我们将6作为4的补数，将上式的减法改写为加法：

9+6=15

去掉高位1（也就是减去10），得到结果5。

对于16进制数，如果从C得到结果5，可以用减法：

C-7=5

因为7+9=16，我们将9作为7的补数，将上式的减法改写为加法：

C+9=15

去掉高位1（也就是减去16），得到结果5。

在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为：

1 00000000

进位1被丢弃

已知一个负数的补码，将其转换为十进制数，步骤：

1、先对各位取反；

2、将其转换为十进制数；

3、加上负号，再减去1。

例如：

11111010，最高位为1，是负数，先对各位取反得00000101，转换为十进制数得5，加上负号得-5，再减1得-6。

位运算符

为了方便对二进制位进行操作，Java给我们提供了 四个 二进制位操作符：

& 按位与

| 按位或

^ 按位异或

~ 按位取反

1. 按位与

一个房间里有两个开关控制房间的灯的明暗。当两个开关同时处于打开状态时，灯才能亮。

开关1 开关2 灯的状态

关 关 暗

开 关 暗

关 开 暗

开 开 亮

按位与

01101101

00110111

00100101

结论：按位与，只有壹(1)壹(1)为1。

Lesson2B

2.按位或

一个房间里有两个开关控制房间的灯的明暗。s当任何一个开关处于打开状态时，灯就能亮。

开关1 开关2 灯的状态

关 关 暗

开 关 亮

关 开 亮

开 开 亮

按位或

01101101

00110111

01111111

结论：按位或，只有零(0)零(0)为0。

3.按位异或

一个房间里有两个开关控制房间的灯的明暗。当两个开关处于不同状态时，灯就能亮。

开关1 开关2 灯的状态

关 关 暗

开 关 亮

关 开 亮

开 开 暗

按位异或

01101101

00110111

01011010

结论：按位异或，只有零(0)壹(1)或壹(1)零(0)为1。

4.按位取反

~ 01101101

10010010

结论：对二进制数按位取反，即0变成1，1变成0。

5.移位运算符

Java中有三个移位运算符

左移：<<

带符号右移：>>

无符号右移：>>>

数 x x<<2 x>>2 x>>>2

17 00010001 00 01000100 00000100 01 00000100 01

-17 11101111 11 10111100 11111011 11 00111011 11

Leeson3C

1. 对类库作了简单介绍和怎样使用。

2. Java.lang.Integer : Static String toHexString( int i ) //将一个十进制数转换成十六进制数

class Test

2{

3 public static void main(String[] args)

4 {

5 int i=0xffffffff ; //i= -1 ;

6 //int c=i<<2; //c= -4 低八位 FC

7 //int c=i>>2; //c= -1;

8 int c=i>>>2; //c= 3F(高八位)

9 System.out.println(i);

System.out.println(Integer.toHexString(c));

}

}
3. 练习：将一个整数110从右端开始的4~7位变为0。

方法： 左移3位 取反

key: 00001111 ------> 01111000 ------> 10000111------->再与110进行与运算

4. 左移一位相当于乘以2，反之，右移一位相当于除以2。

Java的面向对象编程

Class Point : int x; int y; void output(){ println(x/y) };

面向对象编程概述

简单的说，面向对象编程（Object Oriented Programming，简称OOP）描述的是对象之间的相互作用。

面向对象编程与面向过程编程的区别：

过程化程序设计先确定算法，再确定数据结构；

面向对象编程先确定数据结构，再确定运算。

面向过程编程的程序员，习惯于建立数据结构存放数据并定义方法（函数）来操作数据；

面向对象编程的程序员则构造一个对象模型，将数据与方法组织在一起。

Lesson2D

1. 对象 对象的状态 对象的行为

我们可以把 现实世界的事物 抽象成对象。

对象一般都有两个特征：状态（state）和 行为 （behavior）。

软件的对象概念 是由 现实世界对象 抽象而来 。把现实世界对象的状态 保存在软件对象的变量中；现实世界对象的行为 通过软件对象的方法（函数）来实现。

2.类和对象

1) 把相似的对象划归成一个类。

2) 在软件中，类，就是一个模板，它定义了通用于一个特定种类的所有对象的状态（变量）和行为（方法）。

3) 类是创建对象的模板，对象是类的实例。

3.面向对象程序设计

1) 从程序设计的角度看，类是面向对象程序中最基本的程序单元。类实质上定义的是一种数据类型，这种数据类型就是对象类型 。所以我们可以使用类名称来声明 对象变量。

2) 声明对象变量之后，还不能使用对象。必须用运算符new创建对象实体之后，才能使用对象。

Class Point : main(): new pt; pt.x=10;pt.y=5;pt.output();

4.面向对象编程的难点

掌握面向对象的困难之处在于思路的转换。

我们通常习惯于考虑解决问题的方法，而不是考虑将问题抽象成对象再去解决它。

一个简单的例子: 编写一个驾驶汽车的方法

1) 面向过程的程序设计：

编写一个方法，void drivecar();

2) 面向对象的程序设计：

将一辆汽车看成一个对象，将所有汽车对象的共性抽取出来，设计一个类Car，类中有一个方法void drive()，用Car这个类 实例化 一个具体的对象car，调用：car.drive()。

5.类的构造方法

 1) 构造方法的名字和类名相同，并且没有返回值。

 2) 构造方法主要用于为类的对象定义初始化状态。

 3) 我们不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例。

注意：Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法。

Class Point : Point(){初始化};

Point(int a,int b){……}; //构造对象时，系统自动调用。

6.反编译工具：（针对字节码）javap Point (加载的是一个类)

Lesson2E

Java会给用户提供一个 无参 构造函数，一旦用户定义了一个构造函数，则…….

1.new关键字的作用

 1)为对象分配内存空间。

 2)引起对象构造方法的调用。

 3)为对象返回一个引用。

2.缺省构造方法

 当我们用 缺省的构造方法 初始化对象时，系统用 默认值 初始化对象的成员变量。

3.各种数据类型的默认值为：

数值型 0

boolean false

char ‘"0’

对象 null

说白了，就是构造方法可以重载，但构造对象时又去调用哪一个构造方法呢？想一想？

4.方法的重载(overload)

重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。

Class Point: void output(){println(x/y}; || void output(int x,int y){…};

Caution: 当方法中的 形参 与 成员变量 相同时，成员变量 在该方法体内不可见，想可见，用this变量或将参数名改为其它名字。

5.特殊变量this

1) this变量代表对象本身

2) 当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。

3) 使用this简化构造函数的调用。例：Point(){ this(1,1); }

6.关于实例方法和 实例数据成员 的进一步说明

一个类所有的实例（对象）调用的 成员方法 在内存中只有一份拷贝，尽管在内存中可能有多个对象，而 数据成员 在类的每个对象所在内存中都存在着一份拷贝。

Lesson2F

1.this变量允许相同的实例方法为不同的对象工作。每当调用一个实例方法时，this变量 将被设置成引用该实例方法的特定的类对象。方法的代码 接着会与 this所代表的对象的特定数据 建立关联。

Class Point: static void output(){….}; //静态方法，只属类本身，又称类方法。

Main(): Point.output(); //直接用类名去调用静态方法。

2.在静态方法中不能访问 非静态的方法 和 成员变量 。但可访问 静态的成员方法和变量。

Caution: 编程时，脑海中要有内存模型的概念。-----孙鑫老师言

想一想在一个非静态的方法中是否可以访问静态的方法和变量呢？（从内存模型的角度去考虑）。

3.关键字static

 1)静态方法和静态变量是属于某一个类，而不属于类的对象。

 2)静态方法和静态变量的引用直接通过类名引用。

 3)在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以。

eg: 可以用类的对象obj去调用静态的方法method()，如：obj.method()。

Main(): new pt; pt.output(); //static void output(){….};

4.Main()方法也是静态方法，不属于任何一个类。为了解决程序运行的问题。要区分类方法和实例方法，虽然他们都只有一份拷贝（在内存中）。

5.静态成员变量之应用：用于统计计数。

6.常量的定义

final double PI=3.1415926; //必须声明的同时进行初始化。但实际上，可以将初始化工作放在构造函数中。

Lesson2G

1. Point(){ this(1,1);} //语句this(1,1)前面不能有任何语句

2. 常量的定义

 使用关键字final定义常量，例如：final double PI=3.1415926;

注意: 作为一种约定，在定义常量时，通常采用大写形式。

3. final常量可以在声明的同时赋初值，也可以在构造函数中赋初值。为了节省内存，我们通常将常量声明为静态的（static）。

注：static final double PI=3.1415926; 声明同时必须进行初始化（因为有了static修饰）。

Class Animal : int height, weight;| void eat(){…}; void breathe(){…};void sleep(){…}

Class Fish extends Animal:

Class Integration: main(): new an; new fh;||an.breathe(); fh.breathe();fh.height=30;

4. 类的继承

 1) 理解继承是理解面向对象程序设计的关键。

 2) 在Java中，通过关键字extends 继承一个已有的类，被继承的类称为父类（超类，基类），新的类称为子类（派生类）。

 3) 在Java中，不允许多继承。

Class Fish extends Animal: void breathe(){ super.breathe(); 重写这个方法};

5. 方法的覆盖（override）

 1) 在 子类 中 定义一个与父类 同名、返回类型、参数类型均相同的一个方法，称为方法的覆盖。

 2) 覆盖发生在 子类 与 父类 之间。

3) 用super.breathe()来访问被子类覆盖的父类方法

6. 特殊变量super

 1) 特殊变量super，提供了对父类的访问。

 2) 可以使用super访问父类被子类隐藏的变量或覆盖的方法。

 3) 每个 子类构造方法 的第一条语句，都是隐含地调用super( )，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

Lesson2H

Class Animal : Animal(){ print(animal); };

Class Fish extends :Fish(){super(); …. }; //没有父亲，哪有孩子呢？

若类Animal中有自定义构造函数（带参数），则…….

注：构造方法是不能继承的，所以只能用super来代替。

Class Integration: static void fn(Animal an);

Main(): new fh; Animal an; an=fh; Integration.fn(an);

1.多态性

1) 通过覆盖父类的方法来实现，在运行时根据传递的 对象引用，来调用相应的方法。

2) 子类对象的引用 赋给 父类的变量，子类有的方法就调用子类的方法，若子类没有的方法就调用父类的方法。

2. 操作符instanceof的使用：

Main(): new an; new fh; if(an instanceof Animal){..is…} | if(fh instanceof Fish){…is…}.

if(an instanceof Fish){….is…} else{…isn’t…}

if(fh instanceof Animal){…is…} else{…isn’t….}. //子类对象是父类的一个实例

于是，将an = fh;再去判断以上操作？

Lesson2I

面向对象的程序设计

 问题：求一个长方形的周长和面积。

1. 以面向过程的程序设计方式思考：

1) 确定长方形周长和面积的算法。

2) 编写两个方法（函数）分别计算长方形的周长和面积。

3) 求周长的方法（函数）和求面积的方法（函数）需要两个参数，分别是长方形的长和宽。

面向过程的程序设计代码：

class Rectangle

{

static int perimeter(int length,int width)

{

return 2*(length+width);

}

static int area(int length,int width)

{

return length*width;

}

public static void main(String[] args)

{

System.out.println("perimeter = “ + Rectangle.perimeter(5,4));

System.out.println("area = “ + Rectangle.area(5,4));

}

}

2. 以面向对象的程序设计方式思考：

1) 一个长方形可以看成一个长方形对象。

2) 一个长方形对象有两个状态（长和宽）和两个行为（求周长和求面积）。

3) 将所有长方形的共性抽取出来，设计一个长方形类。

4) 通过长方形对象的行为，就可以求出某个具体的长方形对象的周长和面积。

Class Rectangle : int l; int w; | int perimeter(){……}; int area(){… …}

Main(); new rect1; new rect2; rect1.l=10;rect1.w=5; println(…………);