面向对象--三大特性

面向对象--三大特性

以类的方式组织代码，以对象的组织（封装）数据。

三大特性

• 封装：属性私有，set、get

  package oop;
  ​
  public class Student {
      //属性私有（private）
      private String name;//姓名
      private int id;//学号
      private char sex;//性别
  ​
      public String getName() {
          return name;
      }
  ​
      public void setName(String name) {
          this.name = name;
      }
  ​
      public int getId() {
          return id;
      }
  ​
      public void setId(int id) {
          this.id = id;
      }
  ​
      public char getSex() {
          return sex;
      }
  ​
      public void setSex(char sex) {
          this.sex = sex;
      }
  }
  ​

  package oop;
  ​
  public class StudentApplication {
      public static void main(String[] args) {
          Student s1=new Student();
          s1.setName("张三");
          s1.setId(123);
          s1.setSex('男');
          System.out.println(s1.getName());
          System.out.println(s1.getId());
          System.out.println(s1.getSex());
      }
  }
  ​

  运行结果：

  张三 123 男

• 继承:子类继承父类就会有父类的全部方法（ctrl+h【查看继承】）

  package oop.demo01;
  //Person人
  public class Person {
      protected String name="zhangsan";
      private int money=10_0000_0000;
      public void say(){
          System.out.println("说了一句话！");
      }
  ​
      public void print(){
          System.out.println("Person");
      }
  ​
      public Person() {
          System.out.println("Person无参构造执行了！");
      }
  ​
      public int getMoney() {
          return money;
      }
  ​
      public void setMoney(int money) {
          this.money = money;
      }
  }

  package oop.demo01;
  //Student学生 is 人
  public class Student extends Person{
      private String name="xiaohong";
      public void test(String name){
          System.out.println(name);
          System.out.println(this.name);
          System.out.println(super.name);
  ​
      }
  ​
      public Student() {
          //调用父类的构造器，必须要在子类构造器的第一行
          //只能出现在子类的方法或者构造方法中
          //super和this不能同时调用构造方法
          super();
          System.out.println("Student无参构造执行了！");
      }
  ​
      public void print(){
          System.out.println("Student");
      }
      public void test1(){
          print();
          this.print();
          super.print();
      }
  }

  package oop.demo01;
  ​
  public class Application {
      public static void main(String[] args) {
          Student s=new Student();
          s.say();
          System.out.println(s.getMoney());
          s.test("赵四");
          s.test1();
      }
  }

  运行结果：
  Person无参构造执行了！
  Student无参构造执行了！
  说了一句话！
  1000000000
  赵四
  xiaohong
  zhangsan
  Student
  Student
  Person

• 多态

package oop.demo03;
​
public class Person {
    public void run(){
        System.out.println("run");
    }
}
​

package oop.demo03;
​
public class Student extends Person{
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("吃饭！！！");
    }
}
​

package oop.demo03;
​
public class Application {
    public static void main(String[] args) {
​
        //一個對象的實際類型是確定的
        //new Person();
        //new Student();
        //可以指向的引用类型就不确定了:s2--父类的引用指向子类
        //Student:能调用的方法都是自己的或则是继承父类的方法
        Student s1=new Student();
        //Person：父类类型，可以指向子类，但是不能调用子类独有的发方法
        Person s2=new Student();
        Object s3=new Student();
​
        //对象能执行哪些方法，只要看对象左边的类型，和右边关系不大
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
​
        s1.eat();
        //s2.eat();--报错
    }
    /**
     * 多态注意事项：
     * 1.多态是方法的多态，属是没有多态
     * 2.父类和子类要有联系，不然或报错：ClassCastException--类型转换异常
     * 3.存在关系：继承关系，方法需要重写，父类的引用指向子类对象--father f1 = new son();
     * 4.static方法，术语类，不属于实例，不能重写--final常量不能重写----private方法也不能重写
     */
}

运行结果：

son son 吃饭！！！

Instanceof

(类型转换)引用类型，判断一个对象是什么类型

package oop.demo03;
​
public class Person {
    public void run(){
        System.out.println("run");
    }
}

package oop.demo03;
​
public class Student extends Person{
    public void go(){
        System.out.println("go!!!");
    }
}

package oop.demo03;
​
public class Application {
    public static void main(String[] args) {
        //类型之间的转换:父 子
        //高            低
        Person p=new Student();
        //将Person类型转换为Student类型，就可以使用Student的方法论了
        ((Student)p).go();
        //子类转换为父类，可能会丢失自己本来的一些方法
        Student s=new Student();
        s.go();
        Person p2=s;
        //p2.go();//报错
    }
    /**
     * 1.父类的引用指向子类的对象
     * 2.把子类转换为父类，向上转换不用强制转换
     * 3.把父类转换为子类，向下转换：用强制转换
     * 4.方便方法的调用，减少重复的代码
     */
}
​