Java无难事02

1、二进制：一个字节由8个二进位组成，表示是数值的范围是0-255，每一个二进位的值是0或1。

2、原码、反码和补码：
原码：将最高位作为符号位（0代表正，1代表负），其余各位代表数值本身的绝对值。例：+7的原码为 00000111、-7的原码为10000111。
反码：一个数为正，则它的反码与原码相同；一个数如果为负，则符号位为1，其余各位是对原码取反。例：+7的反码为00000111、-7的反码为11111000。
补码：一个数为正，则它的补码与原码相同；一个数如果为负，则符号位为1，其余各位是对原码取反，然后整个数加1。例：+7的补码为00000111、-7的补码为11111001。
已知一个负数的补码，将其转换为十进制数，步骤：1、先对各位取反；2、将其转换为十进制数；3、加上负号，再减去1。

3、位运算符：
& 按位与：都为1结果才为1（只有11为1）
| 按位或：只要有1结果就为1（只有00为0）
^ 按位异或：相反为1，相同为0（只有01或10为1）
～ 按位取反：0变成1，1变成0

4、移位运算符：
<< 左移：补0（移一位相当于十进制乘以2）
>> 带符号右移：正数补0，负数补1（移一位相当于十进制除以2）
>>> 无符号右移：都补0

5、过程化编程设计先确定算法，再确定数据结构；面向对象编程先确定数据结构，再确定运算。

6、构造方法：
无返回值，构造方法名与类名相同；
用于为类的对象定义初始化状态；不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例；
java的类都要求有构造方法，如果没有定义构造方法，java编译器会为我们提供一个缺省（不带参数）的构造方法。

7、方法的重载：
发生在同一个类中，方法的名称相同，但参数类型或参数个数不同。

8、特殊变量this：
this变量代表对象本身；
当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量；
还可以使用this简化构造函数的调用。

class Point
{
	int x,y;
	static int z;
	static final double PI=3.1415926;
	//构造方法
	Point(int a,int b){
		x=a;
		y=b;
		z=5;
	}
	Point(){
       this(1,1);
	}
	//静态方法 
	static void output(){
        System.out.println("dddd");
		System.out.println(z);
		//System.out.println(x);
		//System.out.println(y);
	}
	//方法的重载
	void output(int x,int y){
		this.x=x;
		this.y=y;
		System.out.println(z);
		System.out.println(x);
		System.out.println(y);

	}
	public static void main(String[] args){
	// 静态方法和静态变量的引用直接通过类名引用
        Point.output();
		Point pt=new Point(3,4);
		pt.output(4,5);
		/*Point pt;
		Point pt1;
		pt=new Point(3,3);
		pt1=new Point();
		//pt.x=10;
		//pt.y=10;
		pt.output(5,5);
		pt.output();
		pt1.output();*/
	}

}

9、关键字static:
静态方法和静态变量属于某一个类，而不属于类的对象；
静态方法和静态变量的引用直接通过类名引用；
在静态方法中不能调用非静态的方法和引用非静态的成员变量，反之则可以；
可以用类的对象obj去调用静态的方法method()，如obj.method（）。
静态变量属于类本身，不属于对象。

10、关键字final:
使用关键字final定义常量，例如：final double PI=3.1415926；
作为一种约定，在定义常量时，通常采用大写形式；
final常量可以在声明的同时赋初值，也可以在构造函数中赋初值；
为了节省内存，我们通常将常量声明为静态的（static)。

11、类的继承：关键字extends
不允许多继承；
被继承的类称为父类（超类，基类），新的类称为子类（派生类）。

12、方法重写（方法的覆盖）：
发生在子类与父类之间；
在子类中定义一个与父类同名、返回值类型、参数类型均相同的方法称为方法重写。

13、关键字super:
提供了对父类的访问；
可以使用super访问父类被子类隐藏的变量或覆盖的方法；
在子类的构造函数中，隐含的调用super(),如果父类中没有这种形式的构造函数，那么在编译的时候就会报错；
构造方法不能被继承，只能用super()调用。

class Animal
{
	int height,weight;
	 Animal(int a,int b){
		// System.out.println("animal");

	}
	void eat(){
		System.out.println("animal eat");
	}
	void sleep(){
		System.out.println("animal sleep");
	}
	void breathe(){
		System.out.println("animal breathe");
	}
}
class fish extends Animal
{
	int height;
	void breathe(){
		//super.breathe();
		super.height=30;
		System.out.println("fish bubble");
	}
	fish(){
		super(3,4);//如果没有这句,就会报错
    //System.out.println("fish");
	}
}
class test
{
	static void fn(Animal  an)
	{
		an.breathe();
		an.sleep();
	}
	public static void main(String[] args){
		
		fish fh=new fish();
		Animal an;
		an=fh;
		//test.fn(an);

        //Animal an=new Animal(20,30);
		//an.breathe();
		//fh.breathe();
		//fh.sleep();
		if(fh instanceof fish){
			System.out.println("fh is fish's instance");

		}
        if(an instanceof Animal){
			System.out.println("an is Animal's instance");

		}
		if(fh instanceof Animal){
			System.out.println("fh is Animal's instance");

		}
		else{
			System.out.println("fh isn't Animal's instance");
		}
		if(an instanceof fish){
			System.out.println("an is fish's instance");

		}
		else{
			System.out.println("an isn't fish's instance");
		}
	}
}

14、多态性：
通过重写父类的方法来实现，在运行时根据传递的对象引用，来调用相应的方法。（如下图：传递的是子类fish的引用，调用的就是子类的方法）

(既：当我们将子类对象的引用传给声明为父类的一个对象变量，如果子类有的方法就调用子类的方法，如果子类没有这个方法，那么就调用父类的方法。）

15、二元操作符instanceof:
判断左边对象是否为右边对象的实例；
子类对象是父类对象的实例；

16、练习：采用面向对象程序编程设计计算长方形的周长和面积

class Rectangle
{
	int length,width;
	Rectangle(int a,int b){
		length=a;//赋值写反会出错
		width=b;
	}
	void perimeter(){
		int per;
		per=(length+width)*2;
		System.out.println("per="+per);
	}
	void area(){
		//int area;
		//area=length*width;
		System.out.println("area="+length*width);
	}

	public static void main(String[] args){
		Rectangle reg=new Rectangle(4,5);
		//reg.length=4;
		//reg.width=5;
		reg.perimeter();
		reg.area();
	}

}