Java面向对象编程(三大特征)

1)将属性进行私有化private【不能直接修改属性】
2)提供一个公共的(public)set方法,用于对属性判断并赋值
public void setXxx(类型参数名)//Xxx表示某个属性
//加入数据验证的业务逻辑
属性 = 参数名;
}
3)提供一个公共的(public)get方法，用于获取属性的值
public 数据类型getXxx(){//权限判断,Xxx某个属性
return xX;
}

构造器和 setXxx 结合：

 //构造器与 set方法结合
    public Person(String name, int age, double salary) {
        this.setName(name);
        this.setAge(age);
        this.setSalary(salary);
    }
    public void setName(String name) {
        //加入对数据的校验
        if(name.length() >= 2 && name.length() <= 6){
            this.name = name;
        }else{
            System.out.println("名字的长度不对");
            this.name = "null";
        }
    }
    public void setAge(int age) {//年龄合理就设置,否则给默认年龄,必须在1-120,
        if(age >= 1 && age <= 120){
            this.age = age;
        }else{
            System.out.println("年龄输入不正确，默认年龄为18");
            this.age = 18;
        }
    }

4.面向对象编程特征：继承

概念：

当多个类存在相同的属性 ( 变量 ) 和方法时 , 可以从这些类中抽象出父类, 在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可

继承的基本语法：

class 子类extends 父类{}
1)子类会自动拥有父类定义的属性和方法
2)父类又叫超类,基类。
3)子类又叫派生类。

继承的深入讨论/细节问题：

1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
2) 子类必须调用父类的构造器，完成父类的初始化
3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译失败
4) 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
5) super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)
6) super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7) java 所有类都是 Object 类的子类, Object 是所有类的基类.
8) 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
9) 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。
10) 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

5.super 关键字

super 代表父类的引用，用于访问父类的属性、方法、构造器

基本语法：

1．访问父类的属性，但不能访问父类的private属性
super.属性名;
2访问父类的方法,不能访问父类的private方法
super.方法名(参数列表);
3．访问父类的构造器:
super(参数列表);只能放在构造器的第一句，只能出现一句!

super 和 this 的比较：

No.	区别点	this	super
1	访问属性	访问本类中的属性，如果本从父类开始查找属性类没有此属性则从父类中继续查找	从父类开始查找属性
2	调用方法	访问本类中的方法,如果本类没有此方法则从父类继续查找.	从父类开始查找方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行
4	特殊	表示当前对象	子类中访问父类对象

6.方法重写/覆盖

概念：

子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。

class Person{
    //属性
    private String name;
    private int age;
    //构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //方法
    public String say(){
        return "我是"  + name + "今年" + age + "岁了。";
    }
}
class Student extends Person{
    //属性
    private int id;
    private double score;
    //构造器
    public Student(String name, int age, int id, double score) {//覆盖
        super(name, age);
        this.id = id;
        this.score = score;
    }
    //方法
    public String say(){
        return super.say() + "我的id是" + id + "号，" + "我获得了" + score + "分";
    }//覆盖
}

注意事项和使用细节：

1.子类的方法的形参列表,方法名称,要和父类方法的形参列表方法名称完全一样。
2.子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类。
3.子类方法不能缩小父类方法的访问权限。

6.面向对象编程特征：多态

概念：

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

方法的多态：

重写和重载体现多态

对象的多态：

(1)一个对象的编译类型和运行类型可以不一致
(2)编译类型在定义对象时，就确定了，不能改变
(3)运行类型是可以变化的.
(4)编译类型看定义时=号的左边,运行类型看=号的右边

class Animals {
    public void cry(){
        System.out.println("动物在叫。。。。。");
    }
}
class Cat extends Animals{
    @Override
    public void cry(){
        System.out.println("Cat cry()小猫叫");
    }
}
class Dog extends Animals{
    @Override
    public void cry() {
        System.out.println("Dog cry()小狗叫");
    }
}
public class PolyObject {
    public static void main(String[] args) {
        Animals animals = new Dog();
        animals.cry();
        animals = new Cat();
        animals.cry();
    }
}

多态注意事项和细节讨论：

多态的前提是：两个对象 ( 类 ) 存在继承关系

多态的向上转型：

1)本质:父类的引用指向了子类的对象
2)语法: 父类类型引用名=new子类类型();
3)特点:编译类型看左边，运行类型看右边。
可以调用父类中的所有成员(需遵守访问权限)，不能调用子类中特有成员;
最终运行效果看子类的具体实现!

Animals animals = new Cat();
Object obj = new Cat();//向上转型

多态向下转型：

1)语法: 子类类型引用名=(子类类型)父类引用 ;
2)只能强转父类的引用,不能强转父类的对象
3)要求父类的引用必须指向的是当前目标类型的对象
4)当向下转型后，可以调用子类类型中所有的成员

//多态的向下转型
        // (1)语法：子类类型 引用名 =（子类类型）父类引用;
        Cat cat = (Cat) animals;

Java 重要特性: 动态绑定机制:

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
2.当调用对象属性时,没有动态绑定机制，哪里声明，那里使用

chars_lana

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象编程(三大特征)

目录1.包作用：基本语法：常用的包：注意事项和使用细节：2.访问修饰符使用的注意事项3.面向对象编程特征：封装概念：封装的理解和好处：封装的实现步骤：4.面向对象编程特征：继承概念：继承的基本语法：继承的深入讨论/细节问题：5.super 关键字基本语法：super 和 this 的比较：6.方法重写/覆盖概念：注意事项和使用细节：6.面向对象编程特征：多态概念：方法的多态：对象的多态：多态注意事.
复制链接

扫一扫