面向对象三大特征:封装、继承、多态
目录
访问控制符
Java 提供了 3 个访问控制符：private、 protected 和 public ，代表 3 种不同的访问级别，再加上一个默认的访问控制级别（不使用任何访问控制符），共有 4 个访问控制级别。
- private（当前类访问权限）：类中的一个的成员被 private 修饰，它只能在当前类的内部被访问；
- default（包访问权限）：类中的一个成员或者一个外部类不使用任何访问控制符修饰，它能被当前包下其他类访问；
- protected（子类访问权限）：类中的一个的成员被 protected 修饰，它既可以被当前包下的其他类访问，又可以被不同包的子类访问；
- public（公共访问权限）：类中的一个成员或者一个外部类使用 public 修饰，它能被所有类访问。
我们可以用一个表，来看一下访问修饰符
一个类中同一个包中其他包的子类中全局范围private√default√√protected√√√public√√√√看完了修饰符，我么开始学习封装
封装
- 程序设计追求：高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉！低耦合：仅暴露少量的方法给外部使用！
封装的定义
封装指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。
封装的意义
- 1.提高代码的安全性，保护数据
- 2.隐藏代码的实现细节
- 3.统一接口
- 4.增加系统可维护性
下面我们用代码来实际看一下关于封装的应用：
首先定义一个学生类，在类中我们定义了三个属性，但是属性的修饰符是private
也就是私有的，我们只能在类中去使用这个方法，那么我们在测试类中想要调用它，这时我们可以定义一个公共的方法来使用它- public class Student {
- //private关键字，定义私有属性
- //名字
- private String name;
- //学号.
- private String id;
- //性别
- private String sex;
- }
- public class Student {
- //private关键字，定义私有属性
- //名字
- private String name;
- //学号.
- private String id;
- //性别
- private String sex;
- //通过get用来获取类中的name
- public String getName() {
- return this.name;
- }
- //set给这个属性设置值
- public void setName(String name) {
- this.name = name;
- }
- }
- public class Application {
- public static void main(String[] args) {
- Student student=new Student();
- student.setName("lingstar");
- System.out.println(student.getName());
- }
- }
封装可以也可以对传入其中的数据进行判断，看数据是否合理？
eg：以传入的性别为例
性别只有男或者女，当传入性别为其他时候，我们返回"您输入的性别有误"
我们在类中添加一下代码
代码：- public String getSex() {
- return sex;
- }
- public void setSex(String sex) {
- switch (sex) {
- case " 男":
- this.sex = sex;
- break;
- case "女":
- this.sex=sex;
- break;
- default:
- System.out.println("您输入的性别有误！");
- }
- }
测试代码：- public class Application {
- public static void main(String[] args) {
- Student student=new Student();
- student.setSex("what");
- System.out.println(student.getSex());
- }
- }
- public class Application {
- public static void main(String[] args) {
- System.out.println(student.getName());
- student.setSex("男");
- System.out.println(student.getSex());
- }
- }
继承
- Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
- Java 使用 extends 作为继承的关键字，子类继承了父类，就会获得父类的全部成员变量和方法
- java只有单继承没有多继承
- 私有的(private)东西是无法继承的
代码示例：
我们首先定义一个Person类- public class Person {
- public void run(){
- System.out.println("人会奔跑");
- }
- }
- public class Student extends Person{
- }
- public class Application {
- public static void main(String[] args) {
- Student student=new Student();
- student.run();
- }
- }
输出一下看是否调用Person中的run方法可以用ctrl+h看一下结构
我们可以看到Person类继承于Object类，然后Studet
又继承Person类
super
super在java中两种用法
因为在java中子类没办法直接调用父类的方法或属性，如果想要调用，必须使用java关键字！
写个简单的代码实际体验一下java关键字
先定义Person类：- public class Person {
- protected String name="star";
- }
- public class Student extends Person{
- public String name="lingstar";
- public void test(String name){
- System.out.println(name);
- System.out.println(this.name);
- System.out.println(super.name);
- }
- }
- public class Application {
- public static void main(String[] args) {
- Student student=new Student();
- student.test("星星");
- }
- }
person类：- public class Person {
- public Person(){
- System.out.println("调用了person的无参构造");
- }
- }
- public class Student extends Person{
- public Student(){
- System.out.println("调用了Student的无参构造");
- }
- }
- public class Application {
- public static void main(String[] args) {
- Student student=new Student();
- }
- }
- 调用了person的无参构造
- 调用了Student的无参构造
也就相当于是- public Student(){
- super();
- System.out.println("调用了Student的无参构造");
- }
- }
super总结：
1.super调用父类的构造方法，必须在构造方法的第一个！
2.super必须只能出现在子类的方法或构造方法中！
3.super和this不能同事调用构造方法！
super与this的区别：
代表的对象不同前提条件构造方法this代表本身调用这个对象没继承也可以使用this()本类的构造super代表父类对象的应用只能在继承条件中使用super()父类的构造方法的重写
在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。
注意：重写都是方法的重写与属性无关
eg：
定义一个A类和B类，让A继承B类，里面有一个相同的方法，输出先看一下效果- public class A extends B{
- @Override//注解：有功能的注解
- public void test(){
- System.out.println("A=>test()");
- }
- }
- public class B {
- public void test(){
- System.out.println("B=>test()");
- }
- }
- public class Application {
- public static void main(String[] args) {
- //方法的调用只跟左边，定义的数据类型有关
- A a=new A();
- //a.test调用的是A类的方法
- a.test();
- //父类的引用指向了A
- B b=new A();
- b.test();
- }
- }
- public class A extends B{
- @Override//注解：有功能的注解
- public void test(){
- System.out.println("A=>test()");
- }
- }
有static时，b调用了B类的方法，因为b是用B定义的。
没有static时，b调用的是对象的方法，而b是用A类new的。
重写小结
1.重写需要有继承关系，子类重写父类的方法
2.子类与父类的方法名必须相同,方法体不同
3.参数列表必须相同
4.修饰符的范围可以扩大
5.抛出的异常：范围可以被缩写，但不能扩大：ClassNotFoundException-->Exception(大)
6.重写快捷键AIL+INSERT：Override
为什么要重写?
因为有时父类的功能，子类不一定需要，或者不一定满足
多态
什么是多态？
多态就是同一个行为具有多个不同表现形式或形态的能力。多态只是方法的多态，属性没有多态！
多态存在的条件
1.继承关系，需要有父子类之间的联系
2.方法需要被重写
这些不能重写：
static 方法，属于类，不属于示例
fianl 常量
private修饰
3.父类引用指向子类对象
代码实现
接下来通过代码来体会一下：
先写一个Person类，让他作为Student类的父类- public class Person {
- public void run(){
- System.out.println("人会快速跑");
- }
- }
- public class Student extends Person{
- @Override
- public void run() {
- System.out.println("人也会慢跑");
- }
- }
- public class Application {
- public static void main(String[] args) {
- //一个对象的实际类型是确定的
- // new Student();
- // new Person();
- // 可以指向的引用类型就不确定了：父类的引用指向子类
- //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
- //student能调用的方法都是自己的或者父类的
- Student s1=new Student();
- //Person虽然可以指向子类，但是不能调用子类独有的方法
- Person s2=new Person();
- Object s3=new Student();//如果子类重写了父类，调用子类，如果子类没有重写就调用父类
- s2.run();
- //如果我在子类Student中写一个方法，而用s2去调用是调用不出来的！
- s1.run();
- }
- }
|
