java面向对象三大特征

• 该露的露，该藏的藏

• 我们程序设计要追求高内聚，低耦合 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合：仅暴露少量的方法给外部使用

• 封装（数据的隐藏）

  • 通常，应禁止直接访问一个对象中数据的实际表示，而通过操作接口来访问，这称为信息隐藏

• 记住这句话就够了：属性私有，get/set

• 实现代码如下：

package www.oop.Demo05;

//类 private：私有
public class Student {
    //属性私有
    private String name; //名字
    private int id; //学号
    private char sex;  //性别
    private int age; //年龄

    //提供一些可以操作这些属性的方法！
    //提供一些 public 的get ser //方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
    //快捷键：alt+insert

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){ //对调用方法赋值进行判断
            this.age=3;
        }else{
            this.age = age;
        }

    }
    
}

• 继承的本质是对某一类的抽象，从而实现对现实世界更好的建模

• extends 的意思是扩展，子类是父类的扩展

• Java中只有单继承，没有多继承！简单理解就是：一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子

• 子类继承父类就拥有父类里面的全部方法

• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合、聚合等。

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示

• 子类和父类之间，从意义上讲一个具有“is a”的关系

• 父类中私有(private)属性修饰的方法和属性子类都无法继承

• idea查看继承关系快捷键：Ctrl+h

• object类：Java中所有的类，都默认继承Object类

• super注意点

  1. super调用父类的构造方法，必须在构造器方法的第一个

  2. super 必须只能出现在子类的方法或者构造方法中

  3. super 和 this 不能同时调用构造方法

     Vs this的区别:

     • 代表的对象不同：

       • this：本身调用这个对象

       • super：代表父类对象的应用

     • 前提：

       • this：没有继承也可以使用

       • super：只能在继承条件才可以使用

     • 构造方法

       • this()； 本类的构造器
       • super()；父类的构造器！

• 测试代码如下

package www.oop.Demo06;
// 学生类 派生类 子类
public class Student extends Person {
    
    
        public String name="李四";

    public Student() {
        System.out.println("student无参构造器");
    }

    public void put(){
        System.out.println("Student");
    }
    public void show(){
        put(); //Student
        this.put();//Student
        super.put();//Person
    }

        public void Show(String name){
            System.out.println(name);//输出王五
            System.out.println(this.name);//输出李四
            System.out.println(super.name);//输出张三
        }

}

• 方法的重写
  1. 重写：需要有继承关系，子类重写父类的方法
  2. 方法名必须相同
  3. 参数列表必须相同
  4. 修饰符：范围可以扩大不能缩小 ：public > Protected > Default > private
  5. 抛出的异常：范围可以被缩小，但不能被扩大：ClassNotFoundException —>Exception(大)
  6. 重写：子类方方法和父类必需一致，方法体不同！
  7. 为什么要重写
     • 父类的功能，子类不一定需要，或者不一定满足
     • idea快捷键：Alt + Insert ：Override;
• 测试代码如下

package www.oop.Demo0ee5;
//重写都是方法重写与属性无关
public class superClass {
    public  void show(){
        System.out.println("superClass这是父类的方法");
    }
}

• 动态编译：类型：可扩展性

• 即同一个方法可以根据发送对象的不同而采用多种不同行为方式

• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

• 多态存在的条件：

  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态性

• **instanceof **（类型转换） 引用类型 如何使用代码如下

   public static void main(String[] args) {
          //继承关系
          //Object ---> String
          //Object--->Person-->Teacher
          //Object--->Person-->Student
          Object object=new Student();
          
          //instanceof 用来判断两个类型是否有继承的关系
          System.out.println(object instanceof Student); //true
          System.out.println(object instanceof Person);  //true
          System.out.println(object instanceof Object); //true
          System.out.println(object instanceof Teacher);  //false
          System.out.println(object instanceof String);  //false
  
          System.out.println("==========================");
          Person person=new Student();
          System.out.println(person instanceof Student); //true
          System.out.println(person instanceof Person);  //true
          System.out.println(person instanceof Object); //true
          System.out.println(person instanceof Teacher);  //false
          //System.out.println(person instanceof String);  //编译报错，两者同级毫无关系
  
          System.out.println("==========================");
          Student student =new Student();
          System.out.println(student instanceof Student); //true
          System.out.println(student instanceof Person);  //true
          System.out.println(student instanceof Object); //true
          //System.out.println(student instanceof Teacher);  //编译报错，两者同级毫无关系
          //System.out.println(student instanceof String);  //编译报错，两者同级毫无关系
      }
  

多态注意事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类：有关系的，没关系的会报类型装换异常！ ClassCastException!
3. 存在条件：继承关系，方法需要重新，父类引用指向子类 ！ Father fi=new son();
4. 对象调用方法时候，主要看对象左边的类型 是什么类型就执行该类型的方法，当两个类型都有该方法的时候就执行子类重写父类的方法
5. 不可以重写的方法
   • static 修饰的方法 属于类，它不属于实例
   • final 修饰的 属于常量
   • private 修饰的 属于私有的

package www.oop.Demo07;


import www.oop.Demo06.Person;

public class Application {
    public static void main(String[] args) {
    //一个对象的实际类型是确定的
    // new Student();
    // new Person();

        //可以指向的引用类型就不能确定了：父类的引用指向子类

        //Student 可以调用的方法都是自己的或者继承父类的！
        Student s1=new Student();
        //person （父类） 可以指向子类但不能调用子类独有的方法
        person s2=new Student();

        //对象能执行哪些方法，主要还是看对象左边的类型，和右边关系不大
        s1.run();//子类重写父类的方法 ，执行子类的方法
        s2.run();
        //都输出子类在跑步

       
       


    }
}

1. 父类引用指向子类对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型，强制转换（会丢失方法）
4. 方便方法的调用，减少重复的代码 简洁