Java复习概要——面向对象编程的四大特征-蒲公英云

Java复习概要——面向对象编程的四大特征

小灰灰 2022-03-06 10:54 316阅读 0赞

一、抽象

1、定义：我们在定义一个类的时候，实际上就是把一类事物的共有的属性和行为提取出来，形成一个物理模型，这种研究问题的方法称为抽象。

二、封装

1、定义：封装就是把抽象出来的数据和对象的操作封装在一起，数据被保护在内部，程序的其他部分只有通过授权（成员方法），才能对数据进行操作。

2、访问控制修饰符

java提供四种访问控制修饰符号控制方法和对变量的访问权限：

（1）公开级：用public进行修饰，对外公开

（2）受保护级别：用protected进行修饰，对子类和同一个包中的类公开

（3）默认级：没有修饰符号，向同一个包的类公开

（4）私有级别：用private修饰，只有类本身可以访问，不对外公开

4种访问级别的访问范围
访问级别	访问控制修饰符	同类	同包	子类	不同包
公开	Public	√	√	√	√
受保护	Protected	√	√	√	╳
默认	没有修饰符	√	√	╳	╳
私有	private	√	╳	╳	╳

三、继承

1、继承可以解决代码复用，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends继承。

2、子类通过super来继承父类的构造函数和成员方法。

四、多态

1、所谓多态，就是指引用在不同情况下的多种状态，实现多条的两种方式时继承和接口

2、演示

package face_to_object;
/**
 * 多重多态
 * @author 凡心所向，素履以往，生如逆旅，一苇一航
 *
 */
public class javabase_duotai {
    public static void main(String[] agrs) {
        //非多态演示
        System.out.println("非多态演示：");
        Mao cat = new Mao();
        cat.cry();
        Gou gou = new Gou();
        gou.cry();
        System.out.println();
        //多态演示
        System.out.println("多态演示");
        Dongwu an = new Mao();
        an.cry();
        System.out.println();
        //多重多态演示
        Master master = new Master();
        master.feed(new Gou(), new Bone());
        master.feed(new Mao(),new Fish() );
    }
}
//动物类
class Dongwu{
    String name;
    int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void cry() {  //方法覆盖
        System.out.println("我不知道怎么叫");
    }
    public void eat() {   //方法覆盖
        System.out.println("我不知道吃什么");
    }
}
//食物类
class Food{
    String name;
    public void showName() {
        System.out.println("我是食物");
    }
}
//主人类
class Master{
    public void feed(Dongwu an,Food f) {
        an.eat();
        f.showName();
    }
}
//猫类
class Mao extends Dongwu{
    public void cry() {
        System.out.println("喵喵叫");
    }
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
//狗类
class Gou extends Dongwu{
    public void cry() {
        System.out.println("汪汪叫");
    }
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
//鱼类
class Fish extends Food{
    public void showName() {
        System.out.println("鱼");;
    }
}
//骨头类
class Bone extends Food{
    public void showName() {
        System.out.println("骨头");
    }
}
.............................
非多态演示：
喵喵叫
汪汪叫
多态演示
喵喵叫
狗吃骨头
骨头
猫吃鱼
鱼

附加

一、重载

1、简单的说，方法重载就是在类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。

2、注意事项：方法名相同；方法的参数类型、个数、顺序至少有一项不同；方法的修饰符和返回类型可以不同

3、演示

package face_to_object;
public class javabase_chongzai {
    public static void main(String[] args) {
        Compare com=new Compare();
        System.out.println(com.getMx(1, 2));
        System.out.println(com.getMax(34.5, 1.23));
        System.out.println(com.getMax(34.5, 1));
        System.out.println(com.getMax(6, 1.23));
        System.out.println(com.getMax(34, 1,23));
    }
}
class Compare{
    //返回类型不同
    public int getMx(int a,int b) {
        if(a>b) {
            return a;
        }
        else {
            return b;
        }
    }
    public double getMax(double a,double b) {
        if(a>b) {
            return a;
        }
        else {
            return b;
        }
    }
    //返回顺序不同
    public double getMax(int c,double d) {
        if(c>d) {
            return c;
        }
        else {
            return d;
        }
    }
        public double getMax(double c,int d) {
            if(c>d) {
                return c;
            }
            else {
                return d;
            }
    }
    //返回个数不同
    public int getMax(int i,int j,int k) {
        if(i>j) {
            if(j>k) {
                return i;
            }
            else {
                if(i>k) {
                    return i;
                }
                else {
                    return k;
                }
            }
        }
        else {
            if(j>k) {
                return j;
            }
            else {
                if(i>k) {
                    return i;
                }
                else {
                    return k;
                }
            }
        }
    }
}