java之路，基础知识3

反码：正数的反码和原码相同，负数的反码是原码取反，但符号位不变。
补码：整数的补码和原码一样，负数的补码是反码加1

移位运算：
数            x          x<<2                 x>>2              x>>>2
17      00010001    00 01000100      00000100 01     00000100 01
-17     11101111    11 10111100      11111011 11     00111011 11

面向过程和面向对象的区别：
    过程化程序设计先确定算法，再确定数据结构
    面向过程设计先建立数据结构，再确定算法

类：把相似的对象归成一类，类就是一个模板，它定义了一个通用于特定种类的所有对象的状态和方法
      类是创建对象的模板，对象是类的实例
class Point
{
 int x,y;
 void output()
 {
  System.out.println(x);
  System.out.println(y);  
 }
 
 public static void main(String[] args)
 {
  Point pt = new Point();
  pt.x = 10;
  pt.y = 20;
  pt.output(); 
 }
}
对象的初始化需要new关键字

构造函数：为类的对象定义初始化状态，不能直接调用构造方法，必须通过new关键字来调用。java的类都有构造方法，没有写的，编译器会提供一个默认的缺省构造方法。
缺省构造方法中各种数据的默认值：数值型 0， boolean  false，  char  '\0'，   对象   null
当类中定义了一个构造函数，无论是有参数的还是无参数的，系统都不提供构造函数。
class Point
{
 int x,y;
 Point()
{
 x=5;
 y=5;
}
 Point(int a, int b)
{
 x=a;
 y=b;
}

 void output()
 {
  System.out.println(x);
  System.out.println(y);  
 }
 
 public static void main(String[] args)
 {
  Point pt = new Point();
  pt.output(); 
 }
}
函数重载：名称相同，但是参数的个数，或者参数的形式不同，这样就构成了函数的重载。系统会根据调用时传递的参数类型来确定调用哪个函数。

class Point
{
 int x,y;
 Point(int a， int b)
{
 x=a;
 y=b;
}
Point（）
{
this（1,1）；   //this 前面不能有东西，必须是第一句话
}
 void output(int x, int y)                //参数x与成员变量同名冲突 ，导致没有赋值成功
 {
    x = x;          //应该使用this.x = x;
   y = y;           //应该使用this.y = y;
  System.out.println(x);
  System.out.println(y);  
 }
 
 public static void main(String[] args)
 {
  Point pt = new Point();
  pt.output(3,3); 
  Point pt1 = new Point();
  pt.x = 6；
  pt1.x = 7；
  System.out.println(pt.x);             //        6
  System.out.println(pt1.x);           //        7
 }
}

this变量代表对象本身，当类中有两个同名变量，一个属于类(全局变量)，一个属于方法(局部变量)，使用this变量来区分。
this变量可以简化构造函数的调用，无参构造函数调用有参构造函数
类的方法在内存中只有一份拷贝，但是类的变量在每个对象中都有一份拷贝
 
static 方法，类的方法，属于类，而不是属于某一个对象。 调用的时候直接用类名调用，在类加载时就分配了空间。
static 变量，类的变量，属于类。static方法只能访问static变量，而非静态的方法既可以调用静态变量，又可以调用非静态变量

常量定义 fianl  double  PI =  3.1415926；  常量在定义时必须初始化，或者在构造函数中初始化。

类的继承: extends 关键字，被继承的叫做基类或者父类， 继承的叫做子类。java不允许多继承
class Animal
{
int height；
void eat（）；{}
void breath（）{System.out.println("animal');}
}
class Fish extends Animal
{
  super.breath();
  void breath（）{System.out.println("fish);}
}
子类的方法覆盖了父类的方法，如果要访问父类的方法，那么就调用super方法访问父类中被隐藏的方法。每一个子类在初始化的时候都隐含的调用super（），这就是调用了父类中一个不带参数的构造方法，如果父类中没有相应的方法，那么就会出错。构造方法不可以重载

instanceof  判断一个对象是否是类的实例 
class Animal
{
int height；
void eat（）；{}
void breath（）{System.out.println("animal');}
}
class Fish extends Animal
{
  super.breath();
  void breath（）{System.out.println("fish);}
}
class Inter
{
  public static void main(String[]  args)
 {
Animal  an = new Animal();
  if(an  instanceof  Animal ){}
}

}