开门见山:面向对象的三大特性分别是封装、继承、多态
封装(Encapsulation)
生活案例
ATM、电线
Java中封装的理解
将某些东西进行隐藏,然后提供相应的方式进行获取。
我们程序设计追求“高内聚,低耦合”。
➢高内聚:类的内部数据操作细节自己完成,不允许外部干涉;
➢低耦合:仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性,只对外公开简单的接口。便于外界调用,从而提
高系统的可扩展性、可维护性。通俗的说,把该隐藏的隐藏起来,该暴露
的暴露出来。这就是封装性的设计思想。
封装的好处
提高代码的安全性
代码:通过一个属性感受封装:
public class Girl {
//女孩
//属性:
private int age;
//读取年龄:
public int duquAge(){
return age;
}
//设置年龄:
public void shezhiAge(int age){
if(age >= 30 ){
this.age = 18;
}else{
this.age = age;
}
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//创建一个Girl类的对象:
Girl g = new Girl();
/*g.age = 33;
System.out.println(g.age);*/
//设置年龄:
g.shezhiAge(31);
//读取年龄:
System.out.println(g.duquAge());
}
}
测试结果:
18
上面的代码,对于属性age来说,我加了修饰符private,这样外界对它的访问就受到了限制,现在我还想加上其他的限制条件,但是在属性本身上没有办法再加了,所以我们通过定义方法来进行限制条件的添加
以属性为案例:
进行封装:
(1)将属性私有化,被private修饰--》加入权限修饰符
一旦加入了权限修饰符,其他人就不可以随意的获取这个属性
(2)提供public修饰的方法让别人来访问/使用
(3)即使外界可以通过方法来访问属性了,但是也不能随意访问,因为咱们在方法中可以加入 限制条件。
实际开发中,方法一般会写成 setter,getter方法:
可以利用IDEA快捷键生成:alt+insert -->getter and setter:
加深练习
public class Student {
private int age;
private String name;
private String sex;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
// this.sex = sex;
if("男".equals(sex) || "女".equals(sex)){
this.sex = sex;
}else{
this.sex="男";
}
}
public Student() {
//定义其他带参构造器就必须把空参构造器写上,不然系统不会默认产生空参而报错
}
public Student(int age,String name,String sex){
this.age = age;
this.name = name;
// this.sex = sex;
this.setSex(sex);
}
public static void main(String[] args) {
Student s1 = new Student();
s1.setAge(11);
s1.setName("张三");
s1.setSex("女");
System.out.println(s1.getName()+s1.getAge()+"岁是"+s1.getSex()+"的");
Student s2 = new Student(22,"李四","shhfbben55444");
System.out.println(s2.getName()+s2.getAge()+"岁是"+s2.getSex()+"的");
}
}
运行结果:
张三11岁是女的
李四22岁是男的
继承(Inheritance)
类是对对象的抽象
举例:
荣耀20 ,小米 红米3,华为 p40 pro ---> 类:手机类
继承是对类的抽象
举例:
学生类:Student:
属性:姓名,年龄,身高,学生编号
方法:吃饭,睡觉,喊叫,学习
教师类:Teacher:
属性:姓名,年龄,身高,教师编号
方法:吃饭,睡觉,喊叫,教学
员工类:Emploee:
属性:姓名,年龄,身高,员工编号
方法:吃饭,睡觉,喊叫,工作
共同的东西:
人类:
属性:姓名,年龄,身高
方法:吃饭,睡觉,喊叫
学生类/教师类/员工类 继承 自 人类
以后定义代码:
先定义人类:
人类: ---》父类,基类,超类
属性:姓名,年龄,身高
方法:吃饭,睡觉,喊叫
再定义 : ---》子类,派生类
学生类:Student:
属性:学生编号
方法:学习
教师类:Teacher:
属性:教师编号
方法:教学
员工类:Emploee:
属性:员工编号
方法:工作
狗类:
属性:姓名,年龄,身高
方法:吃饭,睡觉,喊叫
我们的继承关系,是在合理的范围中进行的抽取 ,抽取出子类父类的关系:
上面的案例中:
学生类/教师类/员工类 继承 自 人类 ---》合理
学生类/教师类/员工类 继承 自 狗类 ---》不合理
区分:
学生是一个人
教师是一个人
员工是一个人 ---》合理
学生是一个狗 ---》不合理
总结:继承 就是 is - a 的关系
代码层面解释
先写父类,再写子类:
父类:人类 Person
子类:学生类 Student
public class Person {
//属性:
private int age;
private String name;
private double height;
//提供setter getter方法:
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
//方法:
public void eat(){
System.out.println("可以吃饭。。。");
}
public void sleep(){
System.out.println("可以睡觉。。。");
}
}
public class Student extends Person {
//子类Student 继承 父类Person
//属性:
private int sno;//学号
public int getSno() {
return sno;
}
public void setSno(int sno) {
this.sno = sno;
}
//方法:
public void study(){
System.out.println("学生可以学习");
}
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//创建子类Student的对象
Student s = new Student();
s.setSno(1001);
s.setAge(18);
s.setName("菲菲");
s.setHeight(180.4);
System.out.println("学生名字为:"+s.getName()+",学生的年纪:"+s.getAge());
//访问方法:
s.study();
s.eat();
s.sleep();
}
}
运行结果:
学生名字为:菲菲,学生的年纪:18
学生可以学习
可以吃饭。。。
可以睡觉。。。
继承的好处
提高代码的复用性:
父类定义的内容,子类可以直接拿过来用就可以了,不用代码上反复重复定义了
需要注意的点:
父类private修饰的内容,子类实际上也继承,只是因为封装的特性阻碍了直接调用,但是提供了间接调用的方式,可以间接调用。
内存分析
权限修饰符
【1】private:权限:在当前类中可以访问
【2】default:缺省修饰符:权限:到同一个包下的其他类都可以访问
【3】protected:权限:最大到不同包下的子类
【4】public:在整个项目中都可以访问
总结:
属性,方法:修饰符:四种:private,缺省,protected,public
类:修饰符:两种:缺省,public
以后写代码
一般属性:用private修饰 ,方法:用public修饰
继承条件下构造方法的执行过程
总结
(1)继承关系 :
父类/基类/超类
子类/派生类
子类继承父类一定在合理的范围进行继承的 子类 extends 父类
(2)继承的好处:
1.提高了代码的复用性,父类定义的内容,子类可以直接拿过来用就可以了,不用代 码上反复重复定义了
2.便于代码的扩展
3.为了以后多态的使用。是多态的前提。
(3)父类private修饰的内容,子类也继承过来了。
(4)一个父类可以有多个子类。
(5)一个子类只能有一个直接父类
但是可以间接的继承自其它类。
(6)继承具有传递性:
Student --》继承自 Person ---》继承自Object
Object类是所有类的根基父类。
所有的类都直接或者间接的继承自Object。
多态(Polymorphism)
多态跟属性无关,多态指的是方法的多态,而不是属性的多态。
案例代入
public class Animal {
//父类:动物:
public void shout(){
System.out.println("我是小动物,我可以叫。。。");
}
}
public class Cat extends Animal{
//喊叫方法:
public void shout(){
System.out.println("我是小猫,可以喵喵叫");
}
public void scratch(){
System.out.println("我是小猫,我可以挠人");
}
}
public class Dog extends Animal{
//喊叫:
public void shout(){
System.out.println("我是小狗,我可以汪汪叫");
}
public void guard(){
System.out.println("我是小狗,我可以看家护院,保护我的小主人。。。");
}
}
public class Pig extends Animal{
public void shout(){
System.out.println("我是小猪,我嗯嗯嗯的叫");
}
public void eat(){
System.out.println("我是小猪,我爱吃东西。。");
}
}
public class Girl {
//跟猫玩耍:
/*public void play(Cat cat){
cat.shout();
}*/
//跟狗玩耍:
/*public void play(Dog dog){
dog.shout();
}*/
//跟小动物玩耍:
public void play(Animal an){
an.shout();
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//具体的猫:--》猫的对象
//Cat c = new Cat();
//具体的小女孩:--》女孩的对象
Girl g = new Girl();
//小女孩跟猫玩:
//g.play(c);
//具体的狗---》狗的对象:
//Dog d = new Dog();
//小女孩跟狗玩:
//g.play(d);
//具体的动物:--》动物的对象:
//Cat c = new Cat();
//Dog d = new Dog();
Pig p = new Pig();
Animal an = p;
g.play(an);
}
}
多态的好处
为了提高代码的扩展性,符合面向对象的设计原则:开闭原则。
开闭原则:指的就是扩展是 开放的,修改是关闭的。
注意:多态可以提高扩展性,但是扩展性没有达到最好,以后我们会学习 反射
多态的要素
一,继承: Cat extends Animal ,Pig extends Animal, Dog extends Animal
二,重写:子类对父类的方法shout()重写
三, 父类引用指向子类对象:
Pig p = new Pig();
Animal an = p;
将上面的代码合为一句话:
Animal an = new Pig();
=左侧:编译期的类型
=右侧:运行期的类型
public void play(Animal an){//Animal an = an = new Pig();
an.shout();
}
上面的代码,也是多态的一种非常常见的应用场合:父类当方法的形参,然后传入的是具体的子类的对象,
然后调用同一个方法,根据传入的子类的不同展现出来的效果也不同,构成了多态。
内存分析
总结
(1)先有父类,再有子类:--》继承 先有子类,再抽取父类 ----》泛化
(2)什么是多态:
多态就是多种状态:同一个行为,不同的子类表现出来不同的形态。
多态指的就是同一个方法调用,然后由于对象不同会产生不同的行为。