面向对象2（Java）

2022-05-22 18:04:22 阅读：89 来源： 互联网

标签：Java 子类 System 面向对象 println 父类 public out

封装

基本介绍

该露的露，该藏的藏，我们的程序设计要追求“高内聚，低耦合”：
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
- 低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏）：通常禁止直接访问一个对象中数据的实际表示，而因通过操作接口来访问，这称为信息隐藏
属性私有，get/set
为什么要使用封装：
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增强
方法的重载：如println()方法，按住Ctrl，然后鼠标点击该方法则可以查看具体内容

运用实例

FengZhuang.java

public class FengZhuang {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("李同洲");
        System.out.println(stu1.getName());

        stu1.setAge(999);//岁数不合法，我们可以在Student类中的setAge()中对age进行约束
        System.out.println(stu1.getAge());
    }
}

Student.java

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

    //提供一些可以操作这些私有属性的方法
    //提供一些public的get和set方法

    //get 获得这个数据
    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

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

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

    public void setAge(int age) {
        if (age>0&&age<120){
            this.age = age;
        }else{
            this.age=3;
        }
    }

    public int getAge() {
        return age;
    }
    //学习（）

    //睡觉（）
}

继承

基本介绍

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extands的意思是“扩展”，子类是父类的扩展
Java中类只有单继承，没有多继承
继承是类与类之间的一种关系。除此之外，类与类之间还存在依赖、组合、聚合等关系
继承关系的两个类，一个是子类(派生类)，一个是父类(基类)。子类继承父类，使用extands来表示
子类和父类之间，从意义上讲应该具有“is a”的关系
super注意点：
- super调用父类的构造方法，必须在构造方法的第一个
- super只能出现在子类或者构造方法中
- super和this不能同时调用构造方法
this
- 代表的对象不同：this本身调用着这个对象；super：代表父类对象的应用
- 前提：this没有继承也可以使用；super只能在继承条件中使用
- 构造方法：this本类的构造；super父类的构造
方法重写：需要有继承关系，子类重写父类方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但是不可以缩小（public>protected>default>private）
- 抛出的异常：范围可以缩小但是不可以扩大（ClassNotFindException<Exception）
重写子类的方法必须和父类的方法一致；方法体不同
为什么要重写？（父类的功能子类不一定需要，或者不一定满足！）

运用实例

Test：JiCheng.java

public class JiCheng {
    public static void main(String[] args) {
        WoMen nv1=new WoMen();
        System.out.println(nv1.money);
        nv1.say();
        System.out.println(nv1.getXing());
        nv1.setXing("洲");
        System.out.println(nv1.getXing());

        //super
        Man nan1=new Man();
        nan1.text("li");
        nan1.text2();
        
        
        //静态方法
        //方法的调用之和左边有关，定义的数据类型有关
        B b=new B();
        b.text();//B-->text()
        A a=new B();
        a.text();//A-->text()

        //方法的重写（Override重写）
        //非静态方法（非静态方法和静态方法是有很大的区别的）
        B c=new B();
        c.text();//B-->text()
        //父类的引用指向了子类
        A d=new B();//子类重写的父类的方法
        d.text();//B-->text()
    }
}

父类：Person.java

//在Java中，所有的类，都默认直接或者间接继承Object类
//父类
public class Person /*extends Object(可省略)*/ {
    //public
    //protected
    //default
    //private


    public Person() {
        System.out.println("Person无参");
    }

    /*public Person(String m) {
        System.out.println("Person有参");
    }*/

    public int money=10_0000_0000;//如果属性为private则不能直接继承给子类

    private String xing="李";//如果属性为private，需要通过get/set方法来获取数据，然后把get/set方法继承给子类

    public void say(){
        System.out.println("说话");
    }

    public String getXing() {
        return xing;
    }

    public void setXing(String xing) {
        this.xing = xing;
    }


    //super
    public String name="litongzhou";
    public void print(){
        System.out.println("Person");
    }
}

子类：WoMen.java

//女人 is 人：派生类 is 基类
//子类继承父类，就拥有父类的全部方法！
public class WoMen extends Person{
    //Ctrl+h
}

子类：Man.java

public class Man extends Person {

    //隐藏代码：调用了父类的无参构造
    public Man() {
        super();//调用父类的构造器，必须在子类构造器的的第一行
        System.out.println("Man无参");
    }

    /*public Man() {
        super("m");
        System.out.println("Man有参");
    }*/

    //super
    private String name="李同洲";
    public void text(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void print(){
        System.out.println("Man");
    }

    public void text2(){
        print();
        this.print();
        super.print();
    }
}

父类：A.java

public class A {
    //重写都是方法的重写，和属性无关
    public  void text(){
        System.out.println("A-->text()");
    }
}

子类：B.java

public class B extends A{
    //Override重写
    @Override //注解：有概念的注解
    public void text() {
        System.out.println("B-->text()");
    }
}

标签：Java,子类,System,面向对象,println,父类,public,out
来源： https://www.cnblogs.com/TianCandy/p/16298492.html

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

ICode9

面向对象2（Java）

封装

基本介绍

运用实例

继承

基本介绍

运用实例