se_

一、构造方法Constructor / 构造器

触发的时间节点:构造方法摆在那儿不会主动执行,需要new来触发 构造方法可以重载,为了方便各种new,体现程序的灵活性 构造方法在创建对象时,会自动执行

二、代码块

1.创建对象时:本来是只会触发构造方法,但是,如果有构造代码块,就会触发构造代码块再执行构造方法。
2.调用方法时:顺序执行方法里的代码,如果有局部代码块也就一起执行。
3.执行顺序:new时-构造代码块>构造方法,调用方法时--局部代码块,类加载时--执行静态代码块。
4.构造代码块--用来提取构造方法的共性--new时才触发
5.局部代码块--用来控制变量的作用范围--调用方法时才触发
6.静态代码块--用来初始化项目-位置在成员位置 static{.....}

三、static关键字

1、可以修饰成员变量,成员方法
2、可以直接被类名调用
3、随着类的加载而加载,优先于对象加载   *
4、只加载一次,就会一直存在,不再开辟新空间
5、全局唯一,全局共享
6、static不能和this或者super共用,因为有static时可能还没有对象
7、静态只能调用静态,非静态可以随意调用
8、 静态资源 不存在重写

四、final关键字

1.用法:
--1.让子类的重写权限变得可控,如果父类的某个方法不让子类重写, 可以用final修饰变成最终方法。
--2.表示最终的意思,可以修饰类,成员变量,成员方法。
2.特点:
--1.final 修饰的类,是最终的类,不能被继承
--2.final 修饰的变量,是一个最终的变量,值不能被修改,称之为是 常量
--3.final 修饰的方法,不能被重写

五、this关键字

1.当局部变量名 和 成员变量名 相同时,需要使用this调用成员变量
2.如果在构造方法间,互相调用时,this不能省略
3.位置必须是第一条语句

一、继承

1.继承成员变量:
--子类和父类的变量名不相同时,可以省略super
--子类和父类的变量名相同时,必须使用super来调用父类的资源,不能省略
--this能够调用本类的成员变量
eg(父类 子类 输出测试 调用方法)

2.继承成员方法:
--子类 可以继承父类的方法们(可以直接使用 )
--子类 可以进行扩展(可以直接使用 )
--子类 可以修改继承来的方法(重写override 想要改时 )

3.继承构造方法:
-子类的构造方法里,默认就会存在super()--去调用父类的无参构造
--当创建子类对象时,先执行 父类的构造方法,再执行 子类的构造方法
eg(子类继承父类 无参构造、含参构造 重写构造方法 super)

二、多态

1.概念:
多态主要是指同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态。

2.特点:
1、 多态的前提是继承
2、 要有方法的重写
3、 父类引用指向子类对象,如:Animal a = new Dog();--小到大,向上转型
4、 多态中,编译看左边,运行看右边
--父类引用 指向 子类对象
--编译看左边,运行看右边
(编译看左边--是指想要保存成功,向左边也就是 向父类看齐'统一标准')
(运行看右边--是指结果向右边看齐也就是看子类的干活结果 )

3.总结
1.多态中,的成员变量 -- 用父类的
2.多态中,的成员方法 -- 用父类的方法声明,用子类的方法体
3.静态资源 不存在重写 -- 谁调用就用谁的
4.做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把子类当做父类来看. * 不关心具体子类的类型,把子类当父类看。参数就直接传入父类,体现了通用性。
5.提高了程序的扩展性和可维护性

三、抽象

1.概念:
Java中可以定义没有方法体的方法,该方法由其子类来具体的实现。 该没有方法体的方法我们称之为抽象方法,含有抽象方法的类我们称之为抽象类。 抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

2.特点:
1、 通过java关键字abstract实现
2、 可以修饰方法或者类
3、 抽象类中可以没有抽象方法(由子类去实现)
4、 如果类中有抽象方法,那该类必须定义为一个抽象类
5、 子类继承了抽象类以后,要么还是一个抽象类,要么就把所有抽象方法都重写
6、 多用于多态中
7、 抽象类不可以被实例化

3.总结

  1. 抽象类里有构造方法
  2. 抽象类自己不能实例化,仍然会提供构造方法,因为方便子类new
  3. 当创建子类对象时,会触发子类的构造方法,子类的构造方法里第一条默认就会有一个super()
  4. 构造方法的执行顺序: 父类的 >子类的
  5. 抽象类里可以有变量 也可以有常量
  6. 常量的值不能被修改,final的资源可以被继承但是不可以被修改
  7. 抽象类里可以都是抽象方法,要求子类重写所有的抽象方法,否则就是一个抽象的子类。
  8. 抽象类里可以都是普通方法,目的是不让外界实例化。
  9. 抽象类里包含抽象方法和普通方法,要求子类,重写所有的抽象方法,否则就是一个抽象类。
  10. 抽象类是一个特殊的类,特殊在 抽象类里可以有抽象方法 和普通方法。
  11. 决定类里的方法到底设计成普通方法还是抽象方法?--看方法体有没有必要提供。
四、接口

Java里面由于不允许多重继承,所以如果要实现多个类的功能,则可以通过实现多个接口来实现。

OOP面向对象的编程,如果要提高程序的复用率,增加程序的可维护性,可扩展性,就必须是面向接口的编程,面向抽象的编程,正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

1.概述:
--接口的产生,是为了突破java单继承的局限性
--提倡面向接口,面向抽象编程
--是指把抽象层,修饰成接口或者抽象类

2.特点:
1、 接口中都是抽象方法
2、 通过interface关键字创建接口
3、 通过implements让子类来实现
4、 可以理解成,接口是一个特殊的抽象类
5、 接口突破了java的单继承的局限性
6、 接口和类之间可以多实现,接口和接口之间可以多继承
7、 接口是对外暴露的规则,是一套开发规范
8、 接口提高了程序的功能扩展,降低了耦合性
9、接口和抽象类一样,都不可以被实例化
10、多态对象为了统一调用标准,以父类为准
11、接口里面全都是抽象方法(jdk1.8之后可以是 default、static的普通方法)

3.总结
1.接口里--没有构造方法。
2.接口里的变量--没有。 有static的final的常量。 为变量自动拼接public static final
3.接口里的方法--(jdk1.8之前)都是抽象方法.(jdk1.8之后)可以有用default/static修饰的普通方法。
4.实现类 实现了 接口后,需要重写接口里的 所有抽象方法,否则就是一个抽象的实现类

附:问题--接口里没有构造方法,那么,实现类怎么new的?
答案:不是接口里的构造方法,因为接口根本没有构造方法,其实找的是Object的构造方法

总结

--1,类和类间的关系: 是继承关系extends(继承是强耦合)
--只能是单继承
--class A extends B
--其中A是子类,B是父类
--A类拥有B类的所有功能(除了私有的和构造方法)
--当A类继承了B类的所有功能,想改,会发生方法重写现象
--重写要求:子类的方法声明和父类一样 ,而且, 要有足够的重写权限
--重写的目的:是在不改变原有功能的前提下,修改业务,改的是子类,对于父类原来的功能没有任何影响
--当在子类中,想用用父类的功能时,通过super来调用
--2,接口和接口间的关系: 是继承关系extends
--可以单继承,也可以多继承
--interface A extends B --单继承
--其中,A是子接口,B是父接口
--A接口可以 使用 B接口的所有功能

--interface C extends D , E --多继承
--其中,C是子接口 , D和E是父接口
--C接口可以 使用 D和E接口的所有功能

--3,类和接口间的关系: 是实现关系implements
--不仅可以单实现,还可以多实现,还可以继承的同时再多实现
--class A implements B
--其中,A是实现类,B是接口
--A可以使用接口里的所有功能,但是,需要重写抽象方法,否则就是一个抽象类

--class C implements D,E
--其中,C是实现类,D和E是接口
--要求C需要,同时重写D和E里的所有 抽象方法,否则还是一个抽象的实现类

--class X extends Y implements M,N,O
--其中,X是子类/实现类 ,Y是父类,M N O是接口
--要求X,同时重写 所有 抽象方法,否则还是一个抽象的实现类

--4,抽象类和接口的区别
(Java接口和Java抽象类代表的就是抽象类型,就是我们需要提出的抽象层的具体表现。)
--相同点
--都可以出现抽象方法
--都不能被实例化
--都需要子类重写抽象方法
--接口 和 抽象类 体现了继承结构里的 抽象层
--问题: 抽象层的表现可以是接口?也可以是抽象类?--到底设计成谁?
--答案: 看需不需要提供方法体,
--如果都是抽象方法,那就直接设计成接口,还可以多继承多实现更灵活
--如果有普通方法,那就还是设计成抽象类吧,坏处是只能单继承
--不同点
--抽象类里有构造方法,用来给子类创建对象.接口里没有构造方法.
--抽象类里有变量,但是接口里,只有常量,会为简写的常量自动拼接public static final
--抽象类里有普通方法,但是接口里,都是抽象方法(除了jdk1.8)
--接口里的抽象可以简写,会为简写的抽象方法自动拼接public abstract
--抽象类只能是和子类之间发生单根继承关系
--接口和实现类之间是实现 关系,而且可以 多实现
--接口和接口 之间是继承 关系,而且可以 多继承
--接口 是为了突破java单继承的局限性来的

开闭原则(Open Close Principle)OCP,它是Java世界里最基础的设计原则,它指导我们如何建立一个稳定的、灵活的系统。

  • 开闭原则的定义:是软件中的对象(类、模块、函数等)应该对于扩展是开放的,但是对于修改是封闭的。 开闭原则,是一种设计模式,随着面向对象程序设计的思想,应运而生。
  • 开:指的是可以在源代码的基础上进行扩展,比如继承,接口,抽象类等。在JAVA中,之所以用继承,是在可以直接调用类库的前提下,对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发。
  • 闭:指不允许对原有的代码进行修改。以免影响其他现有功能,造成功能瘫痪。

​形参和实参的区别:

1.形参变量只有在被调用时才分配内存单元,在调用结束时, 即刻释放所分配的内存单元。因此,形参只有在函数内部有效。 函数调用结束返回主调函数后则不能再使用该形参变量。

2.实参可以是常量、变量、表达式、函数等, 无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值, 以便把这些值传送给形参。 因此应预先用赋值,输入等办法使实参获得确定值。

3.实参和形参在数量上,类型上,顺序上应严格一致, 否则会发生“类型不匹配”的错误。

4.函数调用中发生的数据传送是单向的。 即只能把实参的值传送给形参,而不能把形参的值反向地传送给实参。 因此在函数调用过程中,形参的值发生改变,而实参中的值不会变化。

5.当形参和实参不是指针类型时,在该函数运行时,形参和实参是不同的变量,他们在内存中位于不同的位置,形参将实参的内容复制一份,在该函数运行结束的时候形参被释放,而实参内容不会改变。而如果函数的参数是指针类型变量,在调用该函数的过程中,传给函数的是实参的地址,在函数体内部使用的也是实参的地址,即使用的就是实参本身。所以在函数体内部可以改变实参的值。 ​

-形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。
-实参出现在主调函数中,进入被调函数后,实参变量也不能使用。
-形参和实参的功能是作数据传送。发生函数调用时, 主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送。


你可能感兴趣的