JAVA_XXBJ（11）面向对象：封装，继承，多态

面向对象

Java是面向对象的，c语言是面向过程的，那么什么叫面向对象呢，打个比方：去餐厅吃饭，你点了一大桌的菜，你只需要吃就行了，而不用管他是怎么烧的，你所要面对的就是美味佳肴，而这些菜怎么做的你并不需要管。

面向对象的三大特征：封装，继承，多态

封装

封装（Encapsulation）： 是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
其实我们之前已经接触过封装了，public所修饰的就是封装。封装是通过限制只有特定类的对象可以访问这一特定类成员，成员的权限分为三种：公有成员（public），私有成员（private），保护成员（protected）。

下面举一个private栗子：

public class book {
  private String author;
  private String name;
  private int price;
  
  public book(){
   
  }
  public book(String author, String name, int price) {
   //super();
   this.author = author;
   this.name = name;
   this.price = price;
  }
  public String getAuthor() {//获取Author
   return author;
  }
  public void setAuthor(String author) {//改变Author
   this.author = author;
  }
  public String getName() {//获取name
   return name;
  }
  public void setName(String name) {//改变name
   this.name = name;
  }
  public int getPrice() {//获取price
   return price;
  }
  public void setPrice(int price) {//改变price
   this.price = price;
  }
  
}

private将变量设置为私有属性，使得无法对其访问，这样约束了对变量的访问，外部调用的不会无意的将其内部的值修改。那么如何调用，如何修改呢？这就要使用get，set。get是获取，set是改变。
快捷创建get set：
右键->source，选择Generate Getters and Setters

选择你要添加的get 和 set。
那么在其他函数中调用的如下：

public static void main(String[]args){
   book book = new book("张三","java编程思想",85);
  book.setAuthor("李四");
  System.out.println(book.getAuthor()); 
 }

输出的结果是 李四。

继承

继承（Inheritance）： 是指在某种情况下，一个类会有“子类”，子类比原本的类（称为父类）要更加具体化。关键字是 extends。子类可以继承（拥有）父类可被继承的功能和属性（私有化出外），同时还可以创建 自己的功能和属性。
打个比方，有句老话叫“龙生龙，凤生凤，老鼠的儿子生来会打洞”,其实就是子继父，子类有父类的所有，当然父类也有私有的（private），子类也会有比父类多的地方。
关键词extends用在类后面，就像这样：
父类：

public class Person {//人这个类型：Person 人->特征
 String name;//
 int age;
 String address;
 int IdCard;
 public  Person(){
  System.out.println("这是无参构造方法");
 }
public void eat(){//函数
  System.out.println("吃");
 }
 public void drink(){
  System.out.println("喝");
 }
 public void play(){
  System.out.println("玩");
 }
 public void happy(){
  System.out.println("乐");
 }
}

子类：

public class Student extends Person{
 String StuID;
 public void study(){
  System.out.println("当前工作：学习");
 }
}

学生（student）继承（extends）人类（person），学生是子类。虽然子类（student）中只有有一个StuID，但由于继承person，他就同样拥有name age address IdCard这些变量（特征），包括函数，反观父类（person），他并不会有StuID这个变量。
注意：在Java中，继承关系是单继承关系，Object是所有类的父类。所以虽然子类（student）继承父类（person），但子类（person）继承父类（Object），所以子类（student）中同样会有Object的函数。

多态

多态（Polymorphism）： 是同一个行为具有不同表现形式的能力。（同一种事物的不同表现形式），多体现在方法上面。
实现多态有两种机制，分别是：重载和重写。
重载： 同一个类当中，函数名相同，参数列表不同。叫做重载。

public class Student extends Person{
 String StuID;
 public void study(){
  System.out.println("当前工作：学习");
 }
 public void study(String a){
  System.out.println("输出"+a);
  
 }
}

上面这段就是对student.study（）进行了重写，在选择使用哪个函数的时候，通过后面的参数列表，根据就近原理（形式相近）来确定。

重写： 在继承关系当中，方法签名相同（方法名和参数列表都相同），方法体不同，叫做重写。也可以说是覆盖。

public class Student extends Person{
 String StuID;
 public void study(){
  System.out.println("当前工作：学习");
 }
 public void study(String a){
  System.out.println("输出"+a); 
 }
 public void eat(){//方法
  System.out.println("学生吃苦才有甜");
 }
}

在上面的代码中，加入eat（），这个函数在父类（person）中已经有了，且他们的方法签名相同，这时候就产生了覆盖的效果。在main函数中加入以下代码：

public static void main(String[]args){
 Student stu = new Student();
  stu.study("100");
  stu.age=18;
  stu.StuID="202002022020";
  stu.eat();
  Person ss = new Person();
  ss.eat();
}  

我们能够发现，子类中只有一个eat（），而这个eat（）就是重写的那个，返回来看父类中的eat（），只有是父类的对象才会有这个函数。
**向上造型：**父类声明子类对象。
父类声明子类对象：ex：Person s = new student （）
该对象（s）拥有的属性和方法是父类的，但是，当调用子类重写父类的方法的时候，
编译期间执行的是父类的方法，运行期间执行的是子类的方法。
看下面的代码：

  public static void main(String[]args){
 Student stu = new Student();
  stu.study("100");
  stu.age=18;
  stu.StuID="202002022020";
  stu.eat();
  Person ss = new Person();
  ss.eat();
   Person pp = new Student();//向上造型
  pp.eat();
}  

这时候输出的是子类（student）中的eat（），但编译的时候是使用的父类（person)中的eat（）。

例子

主函数：

public class Question_Test {
 public static void main(String[] args) {
  Single_Question single = new Single_Question();
  single.title = "1,以下4人，谁的功夫高（）？";
  single.choice = new String []{"A.叶问","B.张师傅","C.李师傅","D.罗师傅"};
  System.out.println(single.title);//控制台显示问题
  for(int i = 0 ;i<=single.choice.length-1;i++){//循环，挨个输出选项
  System.out.println(single.choice[i]);
  }
  System.out.println("请输入答案：");
  single.answer='A';//标准答案赋值
  Scanner scanner = new Scanner(System.in);
  String answer = scanner.next();
  //将字符串转换成字符数组插入[]
  char [] answers = answer.toCharArray();
  single.check(answers);//调用子类中的检查函数
  boolean flag = single.check(answers);
  if(flag==true){
   System.out.println("回答正确");
  }else{
   System.out.println("回答错误");
  } 
 }
}

父类

public class Question {
 String title;//题干
 String [] choice;//选项
 char [] answers;//输入的答案
 //检测函数，检测答案是否正确
 public boolean check (char [] answer){
  return false;
 }
}

子类

public class Single_Question extends Question {
 char answer;//标准答案 
 public boolean check(char [] answers){//Boolean类，比较    //重写
  if(answers[0] == answer){
   return true;
  }else{
  return false;
  }
 }
}

（个人学习总结，如有错误，敬请斧正，学习时间，20，11）