黑马程序员-面向对象04

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

1.java.lang.Object
Object：所有类的直接或者间接父类，Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。
 
具体方法：
1. boolean equals(Object obj)：用于比较两个对象是否相等，其实内部比较的就是两个对象地址。
而根据对象的属性不同，判断对象是否相同的具体内容也不一样。所以在定义类时，一般都会复写equals方法，建立本类特有的判断对象是否相同的依据。ooo
public boolean equals(Object obj){
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.age == p.age;
}
面试题：
  问 ==  和 equals的区别？
 
  == 比较运算符，equals是Object方法 
  == 在基本数据类型中，比较符合两边的数值是否想的  x == y
  == 在引用数据类型中，比较的是对象的实际地址值  p1 == p2
 
  equals方法，默认比较对象的实际地址值
  可以重写equals方法，建立对象自己的独特比较形式
2. String toString()：将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName() + '@' + Integer.toHexString(hashCode())
为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。 
public String toString(){
return "person : "+age;
}
3. Class getClass()：获取任意对象运行时的所属字节码文件对象。
4. int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。
 
通常equals，toString，hashCode，在应用中都会被复写，建立具体对象的特有的内容。
内部类
当一个类要直接访问另外一个类的成员时，可以将这个类定义到另一个类里面，称为另一个类的内部类。
内部类编译后的文件名为：“外部类名$内部类名.java”；
2.1内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
   之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：  外部类名.this.x   
   this.x--内部类成员变量 
   x--内部类局部变量
2，外部类要访问内部类，必须建立内部类对象。
   //直接访问内部类中的成员。（面试问）
 		Outer.Inner oi  =  new Outer() . new Inner();
      外部类的内部类    先建立外部  再内部成员
2.2内部类定义在成员位置上：
当内部类定义在外部类中的成员位置上，可以使用一些成员修饰符修饰 private、static。
1：默认修饰符。
但是这种应用不多见，因为内部类之所以定义在内部就是为了封装。想要获取内部类对象通常都通过外部类的方法来获取。这样可以对内部类对象进行控制。
2：私有修饰符。
通常内部类被封装，都会被私有化，因为封装性不让其他程序直接访问。 
3：静态修饰符。
如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。
注意；如果内部类中定义了静态成员，那么该内部类必须是静态的。
内部类的访问格式：
1，内部类，内部类中的方法，都是非静态的 
   外部类名.内部类名 变量 = new 外部类对象().内部类对象();
   变量.内部类方法
Outer.Inner oi = new Outer().new Inner();
oi.show();
2，内部类，内部类的方法，都是静态的
 格式：外部类.内部类.内部类方法
         Outer.Inner.show();
3，内部类是静态的，内部类的方法是非静态的
 格式 外部类名.内部类名 = new 外部类.内部类对象
  变量.内部类方法
 Outer.Inner oi = new Outer.Inner();
 oi.show();
注意：当内部类中定义了静态成员，该内部类必须是static的。
      当外部类中的静态方法访问内部类时，内部类也必须是static的。
2.3内部类定义在局部上（方法内）：
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类中的引用。
 但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类-没名字的内部类
1，匿名内部类其实就是内部类的简写格式。一般只用一次就可以用这种形式
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式：new 父类或接口(){定义子类成员或者覆盖父类方法}；
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。	可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
6，使用场景
   当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。
 

练习：补足代码，通过匿名内部类
interface Inter
{
voidmethod();
}

class Test
{
//补足代码。通过匿名内部类。
/* 建立内部类
static class Inner implements Inter
{
public void method()
{
System.out.println("methodrun");
}
}
static Inter function() {
return new Inter()
}
*/
//通过匿名内部类
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("methodrun");
}
};
}

}
class InnerClassTest
{
public static void main(String[] args)
{

//Test.function():Test类中有一个静态的方法function。
//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
//因为只有是Inter类型的对象，才可以调用method方法。

Test.function().method();
}
}

异常
异常概念：就是程序在运行时出现不正常情况。
 * 异常体系 (继承)
 * java将异常这种现象封装成对象，有对象的描述的类
 * java语言中，描述异常的类的顶层父类是 java.lang.Throwable 
 * Throwable可抛出的
 *   |-- Error 错误，程序没有办法了，修改代码。 （癌症，非典 ，艾滋）
 *   |-- Exception 异常。所有异常的父类，可以有针对性的处理方式（发烧） 
无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名才作为子类的后缀名
    这个体系中的所有类和对象都具备一个独有的特点；就是可抛性。
可抛性的体现：就是这个体系中的类和对象都可以被throws和throw两个关键字所操作。
 * 学习一个体系的时候，参考顶层类
 
4.1 异常处理方式有两种：1、捕捉；2、抛出。
第一种异常处理方法
 *   try...catch 代码块
 * 格式
 *    try{
 *      可能出现异常的代码，检测作用
 *      下面代码不执行，直接跳转到catch执行
 *    }catch(异常类 变量){
 *      异常处理代码；
 *    }fianlly{
 *    一定会执行的代码；
 *    }
    
 *    getMessage 少
 *    toString   其次
 *    printStackTrace 最多
功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。
特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在最下面。
 
第二种异常处理方法 抛出异常      
 * throw写在方法内，后面是异常对象 new 出来的
 * throws 写在方法声明上，后面写的是异常类
方法最终调用者要try catch,之前的可以throws
4.2  RuntimeException异常 
 java中，将异常进行了分类，分为2个类
 * 编译时期异常
       当程序调用了一个抛出异常的方法
       这个程序没有任何的异常处理方法，编译失败，调用者必须处理这个异常
 * 运行时期异常 *****
       程序运行的时候，才会出现的异常
       在运行时期异常中，有一个最高的父类 RuntimeException
       RuntimeException和它的所有的子类，都属于运行时期异常
     
    方法中，如果抛出的异常是运行时期异常，那么这个方法的声明，不需要些throws，对于调用者，也不需要进行异常处理
 *  原因是这个异常是不能发生的，一旦发生了运行时期异常，程序必须停止运行，成员修改代码
     
 *凡是以后我们在写程序的时候：
 *    注意，对方传递进来的参数，要进行合法性验证
         参数合法，进行运算
         参数非法，必须提示用户，重新输入
      例如： if(height <=0 || width<=0)
//抛出一个运行时期异常，让程序停止下来，修改代码
     throw new RuntimeException("参数非法，小于或者等于0的矩形不存在");
4.3 自定义异常
出现java中没有封装的异常对象的时候---自定义异常
自定义异常的步骤：
1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。
2：通过throw 或者throws进行操作。异常的信息，通过构造方法，传递给父类
自定义异常练习

//定义一个负数异常
class FuShuException extends RuntimeException
{  //将异常的信息，传递给父类的构造方法Exception(String message)
//子类怎么访问父类的构造方法 super
FuShuException(String msg)
{
super(msg);
}
}
class Demo
{
public static void main(String[] args) {
double d = getDiv(-2.3);
System.out.println(d);
}
public static double getDiv(int a,int b)
{
if(b<0)
throw new FuShuException("出现了除数为负数了");
if(b==0)
throw new ArithmeticException("被零除啦");
returna/b;
}
}

4.4 子父类中的异常
1. 如果父类中的方法，没有抛出异常，子类能不能抛出异常,不能抛出
   父类不抛出，子类不能抛
2. 父类不抛出异常，子类中的重写的方法，调用了一个抛出异常的方法
   子类别无选择，只能try...catch处理这个异常
3. 如果父类的方法，抛出异常，子类的方法呢
   子类，可抛，可不抛
注意：子类抛出的异常，不能比父类抛出的异常大,大小，说的是异常的继承体系
日后我们开发，尽量避免抛出带有子父类关系的异常
 

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------