Object类 &多态 & final关键字&instanceof &复习代码块 &面试题

Object类

类Object是类层次结构的根类。每个类都使用Object作为超类。

equals()方法

指示其他某个对象是否与此对象“相等”。

public class Student extends Object{
	String stuNo;
	String stuName;
	int age;
	public void show() {
		System.out.println("学号:"+stuNo+" 姓名:"+stuName+" 年龄:"+age);
	}
}

public class Test {
	public static void main(String[] args) {
		Student zhangsan=new Student();
		zhangsan.stuNo="bj1805";
		zhangsan.stuName="xxx";
		zhangsan.age=20;
		
		Student lisi=new Student();
		lisi.stuNo="bj1805";
		lisi.stuName="xxx";
		lisi.age=20;
		
		boolean b=zhangsan.equals(lisi);
		boolean b2=zhangsan==lisi;
		System.out.println(b);
		System.out.println(b2);
	}
}

==操作符与equals方法的区别：

1 ==  比较 基本类型比较的是数据 ，引用类型比较对象的引用（地址）

2 默认情况 Object中equals和==一样

3 String类型重写了Object中的equals，所以String比较使用equals方法。

hashCode()方法

返回该对象的哈希码值(理解为对象的地址)。每一个对象的哈希码值唯一

    Object obj1 = new Object();
	Object obj2 = new Object();
	Object obj3 = obj2;
	//obj2与obj3两个对象的哈希码值一样
	System.out.println(obj1.hashCode());
	System.out.println(obj2.hashCode());
	System.out.println(obj3.hashCode());

getClass()方法

返回此Object的运行时类。通过某个对象通过反射获取类。

Object obj = new Object();
Class cls = obj.getClass();//通过反射获取到了Object类

toString()方法

返回该对象的字符串表示。可以在自定义类中重写toString方法，以实现是对象转成指定格式的字符串。

public class Person{
 	String name;
  	public Person(String name){
    	this.name = name;
  	}
  	//重写toString方法
  	public String toString(){
    	return "name="+name;
  	}
}
public class DemoPerson{
  	public static void main(String[]args){
    	Person p = new Person("张三");
      	System.out.println(p);//输出结果为：name=张三
  	}
}

多态

程序中多态：同一个引用类型，使用不同的实例而执行不同操作，一句话理解：父类引用，子类对象。

多态实现步骤：

1 编写父类、子类，子类重写父类方法
2 运行时，使用父类变量，子类的对象

多态使用形式:

1 使用父类作为方法形参实现多态
2 使用父类作为方法返回值实现多态

向上转型，向下转型

向上转型：将子类的对象赋值给父类变量，自动转换

1 <父类型> <引用变量名> = new <子类型>();
2 此时通过父类引用变量调用的方法是子类覆盖或父类的方法 ,编译时看父类，运行时看子类
3 此时通过父类引用变量无法调用子类特有的属性和方法

向下转型：将父类的变量赋值给子类变量，强制转换

Object obj = new String("abc");
String str = (String)obj;
Pet pet=new Dog();  // Pet pet=new Cat();
Dog d=(Dog)pet;

注意：
1 <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
2 在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

final关键字

final：最终的
在Java中声明类、属性和方法时，可以使用关键字final来修饰。

final修饰变量(成员变量或局部变量),则成为（符号）常量，只能赋值一次。

修饰成员变量时，定义时同时给出初始值，或在构造方法中赋值
修饰局部变量时，只能赋值一次

3.2 final修饰方法，则该方法不能被子类重写，能被继承

  final returnType methodName(paramList){
    …
  }

3.3 final修饰类，则类不能被继承
final class finalClassName{
…
}

instanceof

对象向下转型时，存在一个问题：
若一个父类A的引用a，指向一个子类B的实例，将a赋值给另一个子类C引用时，会抛出java.lang.ClassCastException异常；
抛出异常后程序将不能继续向下执行，为了避免这个异常的抛出，我们可以通过instanceof关键字判断引用指向的实例是否可以进行强制转换成某个子类对象

已知Pet类有两个子类Dog和Cat：
public class Demo{
  	public static void main(String[]args){
      	Pet a = new Dog();
      	check(a);
  	}
  	//设计一个方法，判断一个动物是猫还是狗
  	public static void check(Pet a){
      	if(a instanceof Dog){
        	System.out.println("狗");
      	}else if(a instanceof Cat){
        	System.out.println("猫");
      	}
  	}
}

复习代码块

一 局部代码块     位置：局部位置（方法内部）

     作用：限定变量的生命周期，尽早释放，节约内存

     调用：调用其所在的方法时执行

二 构造代码块

     位置：类成员的位置，就是类中方法之外的位置

     作用：把多个构造方法共同的部分提取出来，共用构造代码块

     调用：每次调用构造方法时，都会优先于构造方法执行，也就是每次new一个对象时会自动调用.

三 静态代码块

     位置：类成员位置，用static修饰的代码块

     作用：对类进行一些初始化  只加载一次，
     当new多个对象时，只有第一次会调用静态代码块，
     因为，静态代码块   是属于类的，所有对象共享一份

     调用: new 一个对象时自动调用

面试题？

1、静态代码块、构造代码块、构造方法的执行顺序？

静态-》构造代码块-》构造方法

静态代码块：只执行一次

构造方法：每次调用构造方法都执行

2题
class A{  
    public String show(D obj){  
           return ("A and D");  
    }   
    public String show(A obj){  
           return ("A and A");  
    }   
}     
class B extends A{  
    public String show(B obj){  
           return ("B and B");  
    }  
    public String show(A obj){  
           return ("B and A");  
    }   
}    
class C extends B{}   
class D extends B{}

A a1 = new A();

A a2 = new B();

B b = new B();

C c = new C();

D d = new D();

System.out.println(a1.show(b)); A and A

System.out.println(a1.show(d)); A and D

//A a2 = new B(); 只能看到 return (“A and D”); return (“B and A”);

System.out.println(a2.show(b)); B and A

發表評論

所有評論

還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.

Object类 &多态 & final关键字&instanceof &复习代码块 &面试题