Java（面向对象--抽象类，接口，多态，代理--反射）

最新推荐文章于 2023-10-11 21:43:18 发布

下一秒，待续

最新推荐文章于 2023-10-11 21:43:18 发布

阅读量651

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/taka_is_beauty/article/details/96506712

版权

java 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

一：抽象类

*     概念:
*         什么叫抽象类: 只要一个类是abstract修饰的那么这个类就是抽象类
*                     和这个类中有没有抽象方法,没有必然的联系
*
*         什么叫抽象方法:
*                 方法由abstract修饰,并且没有方法体的方法
*
*         一个抽象类是可以没有抽象方法；因为可能有抽象方法，所以这个类的作用不允许你创建对象（实例化）。
*     作用:
*         不能创建对象,天生作为父类
*         抽象类中的抽象方法有什么作用?
*             1.抽象类中的抽象方法不是为了调用的
*             2.为了强制子类去重写

二 .接口

1.接口的概念

*        接口是功能的集合,就是方法的集合
* 接口中只能定义方法,不能定义普通的成员变量
*
*        而且接口中的成员方法,必须都是抽象的
*        问题:接口能创建对象吗? 不能
*            接口有什么用? 天生作为"父接口"
2.接口的定义
*        定义类用关键字:class
*        定义抽象类用关键字:abstract class
*        定义接口用关键字:interface
*
*        格式:
*        public interface 接口名字{
*            //成员变量,不能定义普通的成员变量
*            //成员方法:必须都是抽象
*            public abstract 返回值类型方法名();
*        }
4.各种类型之间的关系
*        ａ．类和类之间:继承,而且是单继承,一个子类只能有一个直接父类
*        ｂ．接口和接口之间:继承,但是可以多继承,一个子接口可以有多个直接父接口
*
*        面试题:java到底支不支持多继承？
*            如果是类与类　不支持多继承，只支持多层继承
*            如果是接口和接口　支持多继承，也支持多层继承
*        ｃ．类和接口之间: 不叫继承(extends),叫实现(implements),可以多实现
*                    只有类实现接口

5.接口中成员的特点
* 成员变量,但是必须有固定修饰符 public static final 数据类型变量= 值
* 成员方法,必须是固定修饰符 public abstract 即抽象方法

ps：固定修饰符我们可以不写,但是不写不代表没有,编译器自动添加。
* 接口不可以创建对象(抽象类也是)
* 实现类以及实现类接口 ,那么必须重写接口中所有的抽象方法,然后才能创建对象
*            否则这个实现类还是一个抽象类,是不能创建对象的

三：接口和抽象类的异同

1.相同点:
*        a.都不能创建对象
*        b.都是作为父类/父接口
*        c.子类/实现类都必须重写抽象方法,然后才能创建对象
2.不同点:
*        a.抽象类用关键字 abstract 接口用关键字interface
*        b.抽象类中可以有抽象方法,可以没有抽象方法,也可以有部分是抽象方法,部分不是抽象方法
*            接口中只要是方法,必须都是抽象的
*        c.抽象类可以定义任意成员变量 接口的成员变量必须public static final修饰
*        d.类和抽象类之间关系是单继承, 类和接口之间关系是多实现
*        e.思想上的区别
*            1.抽象类中必须定义 整个继承体系的共性内容

ps：继承遵循向上抽取原则，父类代表子类的共性。
*            2.接口中定义 整个继承体系之外的额外的扩展的功能

四：多态

指对象的多态
*            一个对象的多种状态
*            比如: 一只狗是狗,是动物,是生物
*            比如: 一个人是人,是动物,是生物
*            比如: 你在学校是学生,在家里是儿子,在公司员工,在外面老大

ps：通过父类引用指向子类对象，不同的子类可以呈现出不同的状态，就叫多态。
在java中的多态
*            前提:
*                1.必须有子父类关系 (必须有继承)
*                2.必须有方法的重写
*            多态在java中表现形式:
*                父类类型变量名 = new 子类类型();
*                父类类型的变量指向了子类的对象

ps：多态的前提，有继承，有方法重写，有父类引用指向子类对象。

ps：父类引用可以是抽象父类，也可以是父接口。

静态多态：指在编译阶段出现的静态多态，通过方法的重载来达到。

动态多态：指在运行阶段出现的动态多态，通过方法的重写来达到。

注意事项:
*        使用多态调用成员变量
*            编译时看父类看左边
*            运行时看父类看左边
*        使用多态调用成员方法
*            编译时看父类看左边
*            运行时看子类看右边
*
ps：多态使用变量编译运行都看父类，多态调用方法编译看父类运行看子类。

多态的弊端:
*        多态只能调用子父类和子类共有的方法,不能调用子类特有的方法。

多态弊端的解决方法：

* 向上向下转型:
*            向上转型: 多态
*            向下转型: 子类类型变量名 =(子类类型)父类类型的变量;
*                    变量名.子类特有方法();
ps：直接向下转型过程中很容易出现类型转换的异常
*        关键字:运算符 instanceof
*            判断某一个对象是不是属于一个类
*            格式:
*                boolean b = 变量名 instanceof 类名

五：代理

动态语言：不需要编译，在运行阶段确定数据类型；静态语言，需要编译，在编译的时候就能确定数据类型。

反射：是在运行阶段可以获取整个类的方法，属性，构造函数。

获取Class对象：Class clazz=Class.forName("类的全路径"); (最常用)

创建对象的两种方法：

第一种：

Class clazz=Class.forName("reflection.Person");默认需要有空的构造函数。

第二种：

Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class); //创建对象并设置属性
Person p1=(Person) c.newInstance("李四","男",20);

反射的应用场景：如果编译时根本无法预知该对象和类属于哪些类，程序只能依靠运行时的信息来发现该对象和类的真实信息，此时就必须使用到反射了。Person p=new Student();其中编译时类型为Person，运行时类型为Student。

反射总结：

java从反射角度来说属于动态语言，所以说反射就是慢，在运行时候才能确定所属类，但是解决了编译时候无法确定所属类的问题。

代理分为静态代理和动态代理。代理就是使用实现类的方法把调用统一起来。是对实现类的一个封装。

1.创建接口。

2.创建多个实现类。

3.创建一个代理。（类内部有接口对实现类的多态形式）

静态代理：自己手动编写代理类。
   第一步：
1 package ceshi1;
2 public interface Iuser {
3     void eat(String s);
4 }
第二步：
1 package ceshi1;
2 public class UserImpl implements Iuser {
3 　　@Override
4 　　public void eat(String s) {
5 　　　　System.out.println("我要吃"+s);
6 　　}
7 }
第三步：
 1 package ceshi1;
 2 public class UserProxy implements Iuser {
 3 　　private Iuser user = new UserImpl();
 4 　　@Override
 5 　　public void eat(String s) {
 6 　　　　System.out.println("静态代理前置内容");
 7 　　　　user.eat(s);
 8 　　　　System.out.println("静态代理后置内容");
 9 　　}
10 }
动态代理：自动生成代理类。
// 要被增强的对象
final NormalPerson p=new NormalPerson();
// 需求: 使用动态代理的方式对普通人进行增强
// jdk提供的类和方法可以给咱们动态的生成代理对象/增强对象 不需要自己去创建增强类
Person proxyPerson =(Person)Proxy.newProxyInstance(
	p.getClass().getClassLoader(), 
	p.getClass().getInterfaces(),
	new InvocationHandler() {
	/*参数概述 固定死的
	* 参数2: 要被增强的方法
	   * */
		@Override //invoke里面是所有的增强业务逻辑代码
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			if("eat".equals(method.getName()))
			{
				// 参数1:本身应该执行这个方法的对象
				method.invoke(p, args);
				System.out.println("增强了:变成飞...");
				return "abcd";
			}
			return method.invoke(p, args);
		}
	});
proxyPerson.run(); // 执行这个方法  invoke都会执行一遍   执行的内容就是针对该方法的增强
总结：

静态代理：需要手动去实现代理类，非常不灵活。

动态代理：不用手动实现代理类，通过JDK或者cglib自动生成代理对象。

ps：代理类似于装饰者模式的思想。

JDK动态代理：必须要实现了接口的业务类才能用这种办法生成代理对象。新版本也开始结合ASM机制（利用字节码操作机制）。
cglib动态代理：基于ASM机制实现，通过生成业务类的子类作为代理类。