封装 继承 多态 方法重载,方法覆盖

封装: Encapsulation

用private关键字将不想被外界访问到的属性和方法隐藏起来

封装对于类的开发者和使用者都有好处:

对于类的开发者:

能够让数据得到保密,得到隐藏,从而更加安全

对于类的使用者:

能够让使用者将精力 全部集中在核心业逻辑上

类的开发应当 高内聚  低耦合

内聚:独立完成功能的能力, 自强不息,自己的事情自己做

耦合:模块与模块之间的依赖关系

Java当中封装怎么实现解耦:

所有的属性都应当使用private修饰

并且提供两个public的方法 setters 和 getters

设置属性的 用于得到属性的

*封装可以给设置和得到属性一种统一的方式,有助于代码的解耦

*封装可以让程序员重新拿回主动权,让程序员来决定,是否需要用户设置和得到属性

*利用反射 我们可以动态的解析一个类的属性 然后根据规范 得到它的getter和setter方法 从而动态的去设置一个属性或得到一个属性

*所有的方法应当考虑:

一个方法究竟是给外界提供的核心方法还是给核心方法服务的方法

核心方法用public修饰

给核心方法提供服务的方法应当用private对外屏蔽

public class TestEncap {public static void main(String[] args){Student stu = new Student();stu.SetName("Tom");//设置属性stu.setAge(19);System.out.println(stu.getName()+"|"+stu.getAge());}}class Student{//private 访问控制权限修饰符,只能在本类中访问private String name;private int age;//设置属性的方法 setterpublic void SetName(String name){this.name = name;}//得到属性的方法 getterpublic String getName(){//提供了一种统一得到属性的方法return name;}public void setAge(int age){this.age = age;}public int getAge(){return age;}}

继承: Inherit

用extends关键字 建立两个类之间 is a 的关系  = 是一个  是一种

java当中的类只有单根继承,但接口可以多重继承

关于私有属性 能不能被继承,有没有继承,算不算继承

私有属性在子类当中是切实存在的,它是由于java创建对象的流程所决定的

但是不能继续直接使用了,因此不能算作继承得到的

private 访问控制权限修饰符,归根结底是一个修饰符,有没有和能不能被访问是完全不同的两个概念

*:在你日后写代码的每一天当中,只要涉及到代码重用 应当考虑使用继承实现,当然还有其它很多种方式可以实现

public class TestInherit{public static void main(String[] args){Student stu = new Student();stu.eat();stu.sleep();}}class People{String name;public void eat(){System.out.println("People类的eat方法");}public void sleep(){System.out.println("People类的sleep方法");}}class Student extends People{//在这里 可以通过继承得到People类的所有方法 前提:需要public修饰的}

多态: Polymorphism

静态多态:指的是编译时多态 java当中的方法重载

动态多态:指的是运行时多态

一个对象总有多种称呼它的类型 - 一个事物总有多种形态

多态需要注意什么:

对象在内存当中是客观存在的 不会因为改变称呼它的类型而发生任何变化,当你在调用方法的时候,真正方法执行哪个方法 取决于你new的是什么类型的对象

但是编译器看等号左边的类型来进行语法检查

public class TestPoly{public static void main(String[] args){Animal cat = new Cat();//父类类型 = new 子类对象   多态cat.eat();}}class Animal{public void eat(){System.out.println("Animal中的eat方法");}}class Cat extends Animal{public void eat(){System.out.println("cat 类的eat方法");}}

动态多态的出现肯定会伴随着一种语法:

父类类型 = new 子类对象

接口类型 = new 实现类对象

public class TestPoly{public static void main(String[] args){Machine m = new Machine();Car c = new Car();m.run();c.run();m = c;//m = new Car();  多态m.run();}}class Machine{public void run(){System.out.println("这是机器运转的方法");}}class Car extends Machine{public void run(){System.out.println("这是汽车开动方法");}}

方法重载:(方法过载)

Overload / Overloading

放生在同一个类型当中

1.方法名字必须相同

2.返回类型可能不同

*3.参数列表必须不同

参数类型不同 可以算作不同

参数个数不同 可以算作不同

参数顺序不同 可以算作不同

*参数名字不同不能算作不同

*形参的名字不会在.class文件中保存,只会以代号的形式保存

*判读两个方法是否满足重载时 最关键的是参数列表必须不一样,另外还是必须要在同一个类中,方法名且必须一样

//测试方法重载public class TesrOverload {public static void main(String[] args){/*什么情况下使用重载? 我想让一个方法实用性更强 功能更强大System类的out属性时PrintStrema类的对象 println方法被重载了N次System.out.println(5);//intSystem.out.println("Hello");//StringSystem.out.println(true);//booleanSystem.out.println('e');//char*/A aa = new A();aa.show();//调用无参的aa.show(5);//调用形参int数的}}class A{//方法重载,也是静态多态public void show(){System.out.println("show 1");}public void show(int num){System.out.println("show 2");}}

方法覆盖:(方法重写)

Override

发生在有继承关系的父类和子类之间 而且是发生在子类类型当中的

子类继承得到父类的方法之后 觉得方法实现已经不满足我们程序的要求了,然后重新给出了实现

*静态方法能否被覆盖:

静态方法只是对其进行了隐藏,并没有覆盖

方法覆盖 要求符合<进化论> - 物竞天择,适者生存

方法的修饰符 方法签名部分 = 返回类型+方法名+参数列表 异常部分

public void showInteger(int args)throws Exception{}

不能越小 必须完全相同 不能更广泛

方法的修饰符:子类的方法应该比父类的方法更加优秀的,更加优秀的方法就应该让更多的类型可以使用,所以 方法修饰符绝对不允许越变越小 可以是相同的

方法签名部分:除了形参的名字,其他部分必须完全相同

异常部分: 抛出的异常不能更广泛

方法如果越变越优秀,那么决不允许蕴藏着更多的隐患,所以子类抛出的异常必须是父类抛出异常的子类类型

//方法覆盖public class TestOverride {public static void main(String[] args){After60 a90 =  new After90();//多态a90.research();}}class After60{public void research(){//研究新实物的方法System.out.println("去图书馆查阅资料 / 打电话咨询");}}class After90 extends After60{public void research(){super.research();//super代表父类对象  调用父类类型的research方法System.out.println("有问题找Google || 度娘");}}