封装

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

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

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

 package com.oop.demo04;
 ​
 //学生
 //类   public公有   privite私有
 public class Student {
     //属性私有
     private String name;//姓名
     private int id;//学号
     private char sex;//性别
     private int age;//年龄
 ​
     //提供一些操作这些属性的方法
     //提供一些public的 get、set方法
 ​
     //get获得这个数据
     public String getName(){
         return this.name;
     }
 ​
     //set给这个数据设置值
     public void setName(String name){
         this.name = name;
     }
     //alt+insert
 ​
     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;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         if (age > 150 || age < 0) {//不合法
             this.age = 3;
         } else {
             this.age = age;
         }
 ​
     }
 }
 /*
 封装的好处：
     1。提高程序的安全性,保护数据
     2.隐藏代码的实现细节
     3.统一接口
     4.系统可维护性增加了
  */

 package com.oop;
 ​
 ​
 import com.oop.demo04.Student;
 ​
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args){
         Student student = new Student();
         student.setName("为了她");
         //看方法，主要看方法名、参数列表
         System.out.println(student.getName());
 ​
         student.setAge(-2);//不合法的
         System.out.println(student.getAge());
     }
 }

继承

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

extends的意思是“扩展”。子类是父类的扩展。

JAVA中类只有单继承，没有多继承!

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

继承关系的俩个类，一个为子类(派生类)一个为父类(基类)。子类继承父类,使用关键字extends来表示。

子类和父类之间,从意义上讲应该具有"is a"的关系.

object类

super

方法重写 : 重点多态

 package com.oop.demo05;
 ​
 //在java中所有类都默认直接或间接继承Object
 //Person  人 ：父类
 public class Person /*extends Object*/ {
 ​
     private int money = 10_0000_0000;
 ​
     public void say(){
         System.out.println("说了一句话");
     }
 ​
     public int getMoney() {
         return money;
     }
 ​
     public void setMoney(int money) {
         this.money = money;
     }
 }
 /*
         Teacher teacher = new Teacher();
         teacher.say();
 ​
         teacher.setMoney(10_0000);
         System.out.println(teacher.getMoney());
  */

 package com.oop.demo05;
 ​
 //学生  is  人 :派生类,子类
 //子类继承父类就会拥有父类的全部方法
 public class Student extends Person {
     //ctrl+h
 }

 package com.oop.demo05;
 ​
 //Teacher  is  人:派生类,子类
 public class Teacher extends Person {
 ​
 }

super

 super注意点：
     1. super调用父类的构造方法，必须在构造方法的第一个
     2. super必须只能出现在子类的方法或者构造方法中!
     3. super和 this不能同时调用构造方法!
 ​
 Vs this：
     代表的对象不同：
         this： 本身调用者这个对象
         super： 代表父类对象的应用
     前提
         this：没有继承也可以使用
         super：只能在继承条件下参能使用
     构造方法不同
         this()：调用的本类的构造方法
         super()：调用的父类的构造

 package com.oop;
 ​
 import com.oop.demo05.Student;
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args){
         Student student = new Student();
         //student.test("weileta");
 ​
         //student.test1();
     }
 }

 package com.oop.demo05;
 ​
 //在java中所有类都默认直接或间接继承Object
 //Person  人 ：父类
 public class Person /*extends Object*/ {
 ​
     public Person() {
         System.out.println("Person无参执行了");
     }
 ​
     //protected:受保护的一个属性
     protected String name = "为了她";
 ​
     //私有的方法无法被继承
     public void print(){
         System.out.println("Person");
     }
 ​
 }

 package com.oop.demo05;
 ​
 //学生  is  人 :派生类,子类
 //子类继承父类就会拥有父类的全部方法
 //ctrl+h
 public class Student extends Person {
 ​
     public Student() {
         //隐藏代码：调用了父类的无参构造
         //super(); //调用父类的构造器，必须要在子类构造器的第一行
         System.out.println("Student无参执行了");
     }
 ​
     private String name = "自律";
 ​
     public void print(){
         System.out.println("Student");
     }
 ​
     public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
     }
 ​
     public void test(String name){
         System.out.println(name);//weileta :main方法传的值
         System.out.println(this.name);//自律  : 当前类name
         System.out.println(super.name);//为了她 :父类name
     }
 }