java基础-面向对象

面向对象与面向过程：

　　面向过程：需要实现每一个功能时，每一个步骤都要亲力亲为，详细处理每一个细节。

　　面向对象：需要实现每一个功能时，不关心具体的步骤，找一个具有该功能的人来帮我。

类和对象：

　　类：一组相关属性和行为的集合。

　　　　属性：事物的状态信息。

　　　　行为：事物能够做什么。

　　对象：一类事物的具体表现。对象是类的一个实例，必然具有类的相关属性和行为。

　　类与对象的关系：

　　　　类是一类事物的描述，是抽象的

　　　　对象是事物的实例，是具体的

　　　　类是对象的模板，对象是类的实体

　　局部变量与成员变量：

　　　　1.定义位置不一样：

　　　　　　成员变量：在方法的外部，直接写在类中

　　　　　　局部变量：在方法的内部

　　　　2.作用范围不一样

　　　　　　成员变量：整个类中通用

　　　　　　局部变量：只能在方法中使用，方法外失去作用

　　　　3.默认值不一样

　　　　　　成员变量：如果没有赋值，会有默认值，默认值规则和数组一样

　　　　　　局部变量：没有默认值，若要使用手动赋值

　　　　4.内存的位置不一样，成员变量在堆内存，局部在栈内存（了解）

　　　　5.生命周期不一样

 

面向对象三大特征（封装，继承，多态）之封装性：

　　封装性在Java中的体现：

　　　　1.方法本身就是一种封装

　　　　2.关键字private也是一种封装

　　封装性就是将一些细节细信息隐藏起来，对于外界不可见。

　　　　private关键字的作用及使用：

　　　　　　一旦使用了private进行修饰，本类当中可以随意访问，但是超出本类不能直接访问。

　　　　　　间接访问pricate成员变量，使用一对set,get方法

　　　　　　对于setXxx来说，不能有返回值，参数类型必须和成员变量对应。

　　　　　　对于GetXxx来说，不能有参数，返回值类型必须和成员变量对应。

　　

　　构造方法：

　　　　其实就是专门用来构建对象的方法。当我们用new 来创建对象时，其实就是在调用构造方法。

　　　　格式：

　　　　　　public 类名称（参数类型，参数）{

　　　　　　　　方法体　

　　　　　}

　　　　注意事项：

　　　　　　1.构造方法的名称必须要和所在的类名称一致。连大小写也要一样。

　　　　　　2.构造方法不要写返回值类型，连void也不用写

　　　　　　3.构造方法不能return 一个具体的返回值

　　　　　　4.如果没有编写任何构造方法，那么编译器会默认给一个构造方法，没有参数，方法体，什么也不做。public 类名称(){ }

　　　　　　5.一旦编写了至少一个构造方法，编译器则不会赠送构造方法

　　　　　　6.构造方法也是可以进行重载的。重载（方法名称相同，参数列表不同）

　　

面向对象三大特性之继承：

 

　　在父子继承关系中，如果成员变量名称相同，则创建子类对象时，两种访问方式：

　　　　直接通过子类对象访问成员变量： 等号左边是谁，就调用谁的成员变量。

　　　　间接方式： 通过成员方法访问成员变量。

　　在父子继承关系中，创建子类对象，访问成员方法规则：

　　　　创建的对象是谁就优先使用谁的方法。（new谁就用谁的方法）

 　　　　注意事项：

　　　　　　无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

　　重写（Override）：覆盖重写

　　　　概念：在继承关系中，方法名称一样，参数列表也一样。

　　　　重载：重载（方法名称相同，参数列表不同）

　　　　方法覆盖重写的注意事项：

　　　　　　1.必须保证父子类之间方法名称的相同，参数列表也相同。

　　　　　　@override：写在方法的前面，用来检测是不是有效的正确覆盖重写。（这个注解可以不写，只要满足要求就是正确的方法覆盖重写）

　　　　　　2.子类方法的返回值必须【小于等于】父类方法的返回值范围。（注意：object是所有类的公共最高父类）

　　　　　　3.子类方法的权限必须【大于等于】父类方法的修饰权限。（public > protect> (default) >private   注意：此处（default）是什么都不加，留空的意识）

　　　　继承关系中，父子类构造方法的访问特点：

　　　　　　1.子类构造方法中有一个隐含的默认super调用，所以一定是先调用父类构造，后执行子类构造。

　　　　　　2.子类可以通过super关键字调用父类重载构造。

　　　　　　3.super的父类调用必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

　　　　　　总结：子类必须调用父类方法，不写则赠送super（），写了则用指定的super调用，super只能有一个，还必须是第一个。

　

　　抽象方法和抽象类的格式：

　　　　抽象方法：就是加上abstract关键字，去掉大括号，直接分号结束。

　　　　抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

　　　　如何使用抽象类和抽象方法：

　　　　　　1.不能直接创建new抽象类对象

　　　　　　2。必须用一个子类来继承抽象父类。

　　　　　　3.子类必须覆盖重写抽象父类当中所有抽象方法。

　　　　　　覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

　　　　　　4.创建子类对象进行使用。

　　接口：

　　　　接口就是多个类的公共规范。接口时一种数据引用类型，最重要的就是其中的：抽象方法。

　　　　定义一个接口的格式： public interface  接口名称 { }

　　面向对象三大特性之多态性：

　　　　定义：一个对象拥有多种形态（如一个人（对象）既有工人形态又有农民形态）

　　　　多态性在代码中的体现：一句话，父类引用指向子类对象。（左父右子）

　　　　格式：

　　　　　　父类名称  对象名= new 子类名称（）；或者     接口名称 对象名= new 实现类名称（）；

　　　　多态中成员变量的访问方式：

　　　　　　直接通过对象名称访问成员变量：看等号左边是谁优先用谁，没有想上找。

　　　　　　间接通过成员方法访问成员变量：该方法属于谁，优先用谁，没有则向上找。

　　　　多态中成员方法的访问规则：

　　　　　　看new的是谁就优先用谁，没有则向上找。

　　　　　　口诀：编译看左边，（左边是父类，看父类有没有该方法，有编译通过，没有就报错）运行看右边，（右边是 子类，看子类中有没有该方法，没有向上找）。   　　　　　　　　（注：idea中自动编译，编译不通过报红线）

　　　　对比成员方法和成员变量：

　　　　　　成员变量：编译看左边，运行看左边

　　　　　　成员方法：编译看左边，运行看右边

　　　　使用多态的好处：无论右边new的时候换成哪一个子类对象，等号左边的调用方法都不会变化。

　　　　对象的向上转型：其实就是多态的写法

　　　　　　格式：父类名称  对象名 =new 子类名称（）；                                     Animal animal=new Cat();

　　　　　　含义：右侧创建一个子类对象，把他当作父类来看待使用                       创建一只猫，当作动物看待没有问题。

　　　　　　注意事项：向上转型一定是安全的。（从小范围--->大范围）

　　　　对象的向下转型：其实是一个还原的动作。

　　　　　　格式：子类名称  对象名=（子类名称）父类对象；

　　　　　　含义：将父类对象，还原成为本来的子类对象。

　　　　　　注意事项：

　　　　　　1.必须保证对象创建的时候就是猫并且被转型为动物了，才能向下转型为猫。

　　　　　　2.如果对象创建的时候本来不是猫，现在非要向下转型为猫就报错。