标签：封装 name 继承 void Student 父类 super public

封装

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

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

记住这句话就够了:属性私有，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
     }
 }

标签：封装,name,继承,void,Student,父类,super,public
来源： https://www.cnblogs.com/wangshikang/p/15854249.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。