Java编程基础五:面向对象编程中

第五章 面向对象编程 中

1.重写Override/Overwrite

1.1 方法的重写

1. 发生在两个有继承关系的类中，且发生在子类里边(子类认为父类的方法不适用在子类里边，对父类的方法进行重写)

2. 子类重写的方法的权限修饰符要大于等于父类中方法的权限修饰符

3. 重写方法的返回类型在JDk5.0以前需要一模一样，在JDK5.0以后支持斜变类型

   即支持返回其父类的子类类型

4. 子类的异常处理部分要小于等于父类的异常类型

5. @Override注解，表示下边被注解的方法必须要重写父类的某个方法

1.2 方法的重载

方法重载的条件

1. 必须发生在同一个类体

2. 方法名需要完全相同

3. 方法的参数需要不同

   • 参数类型不同

   • 参数个数不同

   • 参数顺序不同

方法重载对返回值类型和修饰符没有要求

方法重载的作用是为了满足用户的不同需求

区分方法的重写和重载

• 二者的概念：

• 重写和重载的具体规则

• 重载：不表现为多态性
  

  重写表现为多态性

2. super的使用

• super理解为父类的，可用来调用属性，方法，构造器

• super的使用

  1. 在子类的方法或构造器中，通过使用super.属性/super.方法的方式，显式的调用父类中声明的属性或方法，通常情况下省略super.
  2. 特殊的：当子类的父类定义同名的属性时，要想在子类中调用父类的属性，必须显式的使用super调用

• super调用构造器

  1. 在子类的构造器中显示的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器
     2. super（形参列表）的使用，必须声明在子类构造器的首行
     3. 在类的构造器中，针对于this（形参列表）或super（形参列表）只能二选一，不能同时出现
  2. 在构造器的首行，没有限时的声明this（形参列表）或super（形参列表），则默认的是父类中空参的构造器
  3. 在类的多个构造器中，至少有一个类的构造器中会用了super（形参列表），调用父类的构造器

3.子类对象实例化过程

1. 从结果来看

   子类继承父类以后，就获取了父类中声明的属性或方法

   创建子类的对象，在堆空间，就会加载所有父类中声明的属性

2. 从过程来看

   通过子类的构造器创建子类对象时，一定会间接或直接的调用其父类的构造器，进而调用父类的父类的构造器，，直接调用了java.lang.Object类的空参构造器为止，因为家在所有父类的结构，所以才可以看到内存中有父类的结构，子类对象才可以考虑进行调用

4. OOP特征三：多态性

1. 多态性可以理解为一个事物的多种形态
2. 对象的多态性，父类的引用指向子类的的对象

Person p1 = new Women();
Person p2 = new Men();

3. 多态的使用：虚拟方法调用

   有了对象的多态性以后，在编译时，只能调用父类中声明的方法，但是在运行期间，实际执行的是子类重写父类的方法，

   编译看左边，执行看右边

4. 多态是运行时行为

5. Object类的使用

• .Object是所有类的父类

5.1 clone()的使用

1. 将Object类的克隆方法权限改大变成public的，然后用super.clone()调用父类的克隆方法,强转成要返回的类型

2. 将要实现克隆方法的类实现允许克隆的接口**(implements Cloneable)**

3. 在main()方法中调用，并抛出异常

   public class Exec1 {
       public static void main(String[] args)throws Exception{
   		OS android = new OS("安卓");
   		OS flyme = android.clone();
   		flyme.name = "魅族";
   		System.out.println(android == flyme);
       }
   }
   class OS implements Cloneable{
   	String name;
   	public OS(String name){
   		this.name = name;
   	}
   
   	@Override
   	public OS clone() throws CloneNotSupportedException{
   		return (OS)(super.clone());
   	}
   }
   

5.2 finalize()

对象的遗言方法，当一个对象要被gc()回收掉的时候回主动执行的一个方法

面试题

final 和 **finalize()**的区别

雷锋和雷锋塔的区别，final是一个修饰符，表示最终的可以用来修饰类，方法，变量

finali是Object类型里边的一个方法，当对象要被回收的时候会主动执行的一个方法

5.3 toString()

• 重写toString()方法。打印自己想要的信息

public class TestToString2{
    public static void main(String[] args){
		Person p1 = new Person("黄晓明",35,'男');
		Person p2 = new Person("baby",28,'女');
		System.out.println(p1);
		System.out.println(p2);
    }
}
class Person{
	String name;
	int age;
	char sex;

	public Person(String name,int age,char sex){
		this.name = name;
		this.age = age;
		this.sex = sex;
	}

	@Override
	public String toString(){
		return name + (sex == '男' ? "\t先生" : "\t女士") + age + "岁";
	}
}

5.4 equals()

重写equals()方法

public class ExecEquals1{
    public static void main(String[] args){
		Food f1 = new Food("猪耳朵拌黄瓜",23,"凉菜");
		Food f2 = new Food("猪耳朵拌黄瓜",25,"凉菜");

		System.out.println(f1.equals(f2));
    }
}
class Food{
	String name;
	double price;
	String type;

	public Food(String name,double price,String type){
		this.name = name;
		this.price = price;
		this.type = type;
	}
	@Override
	public boolean equals(Object obj){
		if(this == obj) return true;
        if(obj == null) return false;
		if(obj instanceof Food){
			Food food = (Food) obj;
			return this.name.equals(food.name) && this.type.equals(food.type);
		}
		return false;
	}

}

5.5.hashCode()

• 得到一个对象的散列将一大组数据分散成不同的小组特征码
• 当equals()方法被重写以后，通常也需要重写hashCode()方法，以便维护hashCode()方法的通用规范，该方法规定相等的对象应该有相等的哈希值

6.包装类的使用

服务于集合

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character(不存在parse方法)

1. java提供了八种基本数据类型对应的包装类，使得基本数据类型的变量具有了类的特征。

6.1 基本数据类型，包装类，String的相互转换

public class WrapperTest{
    public static void main(String[] args){
        
    }
    @Test
    public void test1(){
        
    }
    //自动装箱   基本数据类型 --> 包装类
    int num1 = 10 ;
    Integer in1 = num1;
    
    //自动拆箱    包装类 --> 基本数据类型
    int num2 = in1; 
    //基本数据类型，包装类   --->String类型
    int  num = 10;
     //方式一 连接运算
    String str1 = num + "";
    //方式二 :调用String的valueOf(Xxx xxx)
    float f1 = 1.3;
   String str2 = String.valueOf(f1);
    
    //String  --> 基本数据类型，包装类
    String str3 = "123";
    int num4 = Integer.paserInt(str3);
} 

例题

Object obj1 = true ? new Integer(1) : new Double(2.0);
System.out.println(ojb1);
//结果为1.0
//三元运算符运算式要保证两个结果类型一致。所以会对Integer类型的进行自动类型提升  变为Double型


//***************************
Object obj2;
if(true)
    obj2 = new Inetger(1);
else
    obj2 = new Double(2.0);
System.out.println(ojb2);

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println( i == j);//false
//Integer内部定义了IntegerCache的结构，在其中定义了Integer[]
//保存了-128~127范围的整数，如果用自动装箱的方式，给Integer固执的范围在这个范围内，可以直接使用数组的元素，不用new了，提高了效率
Integer m = 1;
Integer n = 1;
System.out.println( m == n);//false

Integer i = 128;
Integer j = 128;
System.out.println( x == y);//false