0101-面向对象特性

最新推荐文章于 2024-11-12 14:54:23 发布

龙腾四海365

最新推荐文章于 2024-11-12 14:54:23 发布

阅读量323

点赞数

分类专栏： java 面试 Java面试总结文章标签： Java 面向对象重写和重载面试

本文链接：https://blog.csdn.net/u011637069/article/details/85058853

版权

java 同时被 3 个专栏收录

106 篇文章 1 订阅

订阅专栏

面试

5 篇文章 0 订阅

订阅专栏

Java面试总结

5 篇文章 0 订阅

订阅专栏

1 面向对象

1.1 面向对象是什么

面向对象：object oriented programming OOP
面向对象是一种开发方法，是一种思想
面向对象是一种对现实世界的理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物

1.2 面向对象三大特性

1.2.1 封装

什么是封装
封装是指将数据与具体操作的实现代码放在某个对象内部，使这些代码的实现细节不被外界发现，外界只能访问该对象对外开放的方法与属性。
封装的好处
封装能隐藏对象实现细节，使代码更易维护。同时因为不能直接调用、修改对象内部的私有信息，在一定程度上保证了系统安全。
举例说明
“人”本身可以看作一个完整的封装，有姓名、年龄、性别等属性，有走路、吃饭、睡觉等方法。
性别、身高这些是对外暴露的属性，别人直接可以知道。而体重、年龄、姓名等属于个人隐藏属性，只能通过特定等方法（询问、称量）才能获取。

1.2.2 继承

什么是继承
继承在本质上是特殊——一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。
例如儿子继承父亲的财产。
继承的好处
a. 可以复用这些类的方法和域；
b. 可以添加新的方法和域，从而扩充了类的功能；
继承的缺点
a. 打破了封装性，子类依赖于超类的实现细节，和超类耦合；
b. 超类(父类)更新后可能会导致错误；
代码示例：

class MyHashSet<E> extends HashSet<E> {
    private int count;

    @Override
    public boolean add(E o) {
        count ++;
        return super.add(o);
    }

    @Override
    public boolean addAll(Collection c) {
        if (c == null) {
            return false;
        }
        count += c.size();
        return super.addAll(c);
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        MyHashSet<Integer> myHashSet = new MyHashSet<Integer>();
        myHashSet.addAll(Arrays.asList(1,2,3));
        System.out.println("count:" + myHashSet.count);
    }
}

输出结果：

count:6

运行后会发现，加入了3个元素之后，计数器输出的值是6。原因分析：

进入到超类中的 addAll() 方法就会发现出错的原因：它内部调用的是 add() 方法。所以在这个测试里，进入子类的 addAll() 方法时，数器加3，然后调用超类的 addAll() ，超类的 addAll() 又会调用子类的 add() 三次，这时计数器又会再加三。

1.2.3 多态

什么是多态
所谓多态，即多种形态。

比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：

酒 a = 剑南春
酒 b = 五粮液
酒 c = 酒鬼酒
…

这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。
多态的好处
a. 同一类型的引用指向不同的对象时，有不同的实现；
b. 同一个对象被造型为不同的类型时，有不同的功能；
demo

//向上造型
public class UpDemo {
	public static void main(String[] args) {
		Boo o1 = new Coo(); //向上造型
		Coo o2 = (Coo)o1; //正确，o1所指向的对象就是Coo类型
		Inter3 o3 = (Inter3)o1; //正确，o1所指向的对象实现了Inter3接口
		//Doo o4 = (Doo)o1; //类型转换异常(ClassCastException)
		
		if(o1 instanceof Doo){
			Doo o5 = (Doo)o1;
		}
	}
}
 
interface Inter3{
}
class Boo{
}
class Coo extends Boo implements Inter3{
}
class Doo extends Boo{
}

1.3 面向对象优点

1.3.1 面向对象

优点：
易维护、易复用、易扩展。由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
缺点：
性能比面向过程低，设计成本高。

1.3.2 面向过程

优点：
性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：
没有面向对象易维护、易复用、易扩展。

2 Java 四种修饰符

2.1 Java 的四种修饰符关键字

public、protected、default、private

2.2 权限范围

访问权限	本类	本包	子类	其他包
public	∨	∨	∨	∨
protect	∨	∨	∨	x
default	∨	∨	x	x
private	∨	x	x	x

2.3 存在的原因

a. 让调用者无法触及他们不应该触及的部分
b. 允许库设计者可以改变类内部的工作方式而不用担心会影响到调用者
c. 为封装、继承和多态提供依据及保障

3 重载和重写

3.1 方法的重载 (Overload)

3.1.1 什么是方法重载

一个类中，方法名称相同，参数列表不同，称方法的重载
编译器在编译时，自动根据方法的签名绑定调用不同的方法

3.1.2 方法重载的作用

方便根据不同的参数个数，顺序，类型，自动匹配方法，减少写过个函数名或方法名的重复步骤
不用为了对不同的参数类型或参数个数，而写多个函数

3.1.3 方法重载的意义

当对某个方法升级时，可以重载此方法，增加参数，减少因方法名改变引起的歧义。

3.1.4 demo

/*
 * 1.一个文件中可以包含多个类
 * 2.public修饰的类只能有一个
 * 3.public修饰的类必须与文件名相同
 */
//重载的演示
public class OverloadDemo {
	public static void main(String[] args) {
		Aoo o = new Aoo();
		o.say();
		o.say("zhangsan");
		o.say(23);
		o.say("zhangsan", 23);
		o.say(23, "zhangsan");
	}
}
 
class Aoo{
	void say(){}
	void say(String name){}
	void say(int age){}
	void say(String name,int age){}
	void say(int age,String name){}
	
	//int say(){ return 5;} //编译错误，与返回值类型无关
	//void say(String address){} //编译错误，与参数名无关
}

3.2 方法的重写 (Override)

3.2.1 什么是方法重写

发生在父子类中，方法名相同，参数列表相同，方法体不同
重写方法被调用时，看对象的类型

3.2.2 方法重写的要求

发生方法重写的两个方法返回值、方法名、参数列表必须完全一致
子类抛出的异常下不能超过父类相应方法抛出的异常
子类方法的访问级别不能低于父类相应方法的访问级别

3.2.3 方法重写的作用

重写是为了增强类的重用性和复用性，扩展性；
重写是对类中方法的扩充，因为继承用的是父类的东西，重写则不仅得到父类的东西，同时也加入了自己的东西

3.2.4 demo

public class OverrideDemo {
	public static void main(String[] args) {
		OAoo o1 = new OBoo(); //向上造型，父类引用指向子类对象
		OAoo o2 = new OCoo();
		test(o1);
		test(o2);
	}
	public static void test(OAoo oo){
		oo.show();
	}
 
}
class OAoo{
	void show(){
		System.out.println("Aoo-show()");
	}
}
class OBoo extends OAoo {
	void show(){
		System.out.println("Boo-show()");
	}
}
class OCoo extends OAoo {
	void show(){
		System.out.println("Coo-show()");
	}
}