Java知识点整理：第七章：static关键字、final关键字、抽象类 、接口、Object类

1.static关键字

1.static可以修饰属性，方法，内部类，代码块 
static修饰属性: 
 a.static修饰的属性是类级别的.属于类全体对象共享的变量.只有一份.
 b.静态属性是在类的加载期间初始化的.
       
    c.静态属性的访问通过类名.属性访问。
 
static修饰方法
static修饰的方法，属于类级别.
一般用来表示工具方法.
还是通过类名.方法调用.
所有的对象共享此方法.

Math.random();
static修饰代码块:
{} --->new对象的时候执行
static{}---->类加载的时候执行.只会执行一次.

静态代码块用于静态资源文件的加载(图片，音乐，视频,配置文件..)

 
static修饰内部类(在内部类的阶段讲解.)

2.final关键字

最终的
final可以修饰类,变量，方法. 
final修饰类,此类不能被继承.
final修饰变量，变量不可以改变.
final修饰方法，方法是不可以被重写的.

常量
通过publicstatic final修饰的变量.

public static final int a = 5;

常量名一般大写。

public static final  int B = 5;
 
经典笔试题;

class Roo{

static int a = 1 ;

int b = 2;

}

main{

   final Roo  roo = new Roo();

   Roo roo1 = new Roo();
   roo =roo1; //
错误.
   roo.a = 2;//正确，不建议这么写
   roo.b = 4; //正确.
 

}

3.抽象类

不具体的类，包含有抽象方法的类.
   
   
抽象方法：
      
只有行为的概念，没有具体的行为实现.
 
   
如何定义抽象方法，抽象类？
   
使用abstract关键字修饰类就是抽象类
     public abstract class Shape{

 
     }
   
使用abstract关键字修饰方法就是抽象方法.
     public abstract double area();
  
   
继承了抽象类以后必须要实现抽象类中的所有抽象方法.
 
   
抽象类是不能实例化对象的.
 
   
包含有抽象方法的类是抽象类，但是抽象类不一定包含抽象方法.
  
   
什么情况下继承了抽象类后可以选择性的实现抽象方法?
    abstract class Animal{
       abstract void go();
       abstract void eat();
    }
    abstract class PXAnimal extends Animal{

void go(){
print("爬");

}
 

abstract void eat();
 
    }
    abstract class FXAnimal extends Animal{

void go(){
print("飞");

}

abstract void eat();
    }
 
   
什么时候要定义抽象类?
抽象方法--->抽象类
    
如果有行为的概念，没有具体行为的实现.就要定义成抽象方法.

4.接口

    通过interface定义接口
   
通过implements实现接口
 
   
继承只能继承一个类
 
   
规范.
   
接口是一个特殊的抽象类.
   
接口中的所有方法都是抽象方法.
   
接口中除了抽象方法以外，只能定义常量.
 
  
实现接口(继承)
   
接口是不能被实例化的.
   
接口只能被实现(implements),
   
一个具体类实现接口，必须实现全部的抽象方法.
   
可以同时实现多个接口
   
一个东西既是...又是....
 
   
接口中只能定义常量以及抽象方法
   
定义常量可以省略public static final
   
定义方法可以省略public abstract
 
   
接口与接口之间可以继承.
    interface A{}
    interface B{}
    A extends B{}
 
   
一个具体的类可以同时继承类与实现接口.

5.object类

Object类是一切类的父类，
java中所有类都间接或直接继承Object
 
所有的类都继承了Object的属性和方法

toString()  equals()hashCode() 
 
1.toString()方法是当前对象的文本描述
  Object类中此方法的默认实现:
     
全限定名@hashcode
   
例如:Point

    oop.day05.Point@6cedf
  toString是系统默认调用的，在打印对象的时候默认调用。

 System.out.println(p);

 System.out.println(p.toString());
 
对toString()方法进行重写。

根据实际的情况，想要打印对象的什么内容就对toString()怎样重写。
2.equals()比较两个对象的属性是否相等

比较相等：
==               引用相等(比较对象的地址)
obj.equals(other)
对象相等(是比较对象的属性)
Object中，equals默认就为==
所以一般重写equals()

重写的规则：
自反性：对于任何非空引用值x，x.equals(x)返回值都为true
对称性：对于任何非空引用值x，y，
当x.equals(y)为true时，
y.equals(x)也为true
传递性：对于任何非空引用值，x，y，z
x和y相等，y和z相等，那么z和x也相等
一致性：对于任何非空引用值x和y，多次调用x.equals(y)
始终返回true，或false。
前提是对象上的equals的信息没被修改的。
对于任何非空引用值x，x.equals(null)都返回false
 

Point{

int x;

int y;

public boolean equals(Object obj){

if(obj == null){

return false;

}else if(this == obj){

return true;

}else if(obj instanceof Point){

Point other = (Point)obj;

return this.x == other.x &&

       this.y == other.y;

}

return false;

}

}
 
3.hashCode()方法返回对象的hashCode值
hashCode方法建议(必须)与equals一同重写

重写规则：
当两个对象equals相等，那么hashCode值要相等
当两个对象equals不相等，
如果是同一个类的对象，那么hashCode值要保证不相等

如果是不同类的对象，那么无所谓
默认的hashCode值是当前堆对象地址blabla出来的一个整数，

不是内存地址。可以间接的认为就是内存地址
 
一般会使用对象的OID作为hashCode值
OID是对象的唯一编号，在一个项目中，一般采用数据库生成ID，

即数据库的主键
注：重写equals后，建议(必须)重写hashCode方法！！！