Day15-01 P66 面向对象07简单小结类与对象 P67 对象08:封装详解 P68对象09 什么是继承 P69面向对象10 Super详解 P70 面向对象11:方法重写

Day15–01

P66 面向对象07:简单小结类与对象

/*
总结 类与对象:
     1、类是一个模板,类是抽象的,对象是一个具体的实例

方法:
     1、定义和调用

对象的引用:
     引用类型: 八大基本类型(byte short int long float double char boolean)
     对象是通过引用来操作的:栈--->堆

 属性:字段Field 成员变量
     默认初始化:
         数字:0  0.0
         char: u0000
         boolean: false
         引用类型: null

       修饰符  属性类型 属性名 = 属性值

对象的创建和使用
      必须使用new 关键字创建对象,构造器   Person kuangshen = new Person();
      调用对象的属性: kuangshen.name
      调用对象的方法: kuangshen.sleep()

 类包含的:
       静态的 属性
       动态的 方法
 */


P67 面向对象08:封装详解

在这里插入图片描述

快捷键:alt + ins 快速生成get set 方法,如下图

在这里插入图片描述
在这里插入图片描述

代码

以下两个代码是互动的,一个是main启动程序,一个是类

package com.oop.demo04;

//类   private:私有
public class Student {

    //属性私有
    private String name;//名字//前面加private,把这个属性name私有
    private int id;//学号
    private char sex;//性别
    private int age;

    //private私有这些属性后无法像以前一样直接对象调用这些属性
    //提供一些可以操作这个属性的方法
    //提供一些public 的 get set 方法

    //get 获得这个数据 (获取哪个数据方法名就用get啥啥 如这里的getName)
    public String getName(){ //我们写一个公共的方法来获取加private的name这个数据
        return this.name;  //在另一个程序里用 s1.getName();回车 来获取name这个数据
                           //就不能像之前用s1.name;回车 来获取name数据了
    }

    //set 给这个数据设置值 (给啥啥数据设置值 方法名就用set啥啥 如这里的setName)
    public void setName(String name){
        this.name = name;//this.的意思是this所在的当前这个页面Student
        //这个类,等于把外界赋给形参String name的值 赋与给当前类中的this.name
        // (也是当前Student类中的private String name;中的这个name赋值)
    }

    //这里用快捷键alt+insert快速生成其他几个private变量的set和get方法
    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>120 || age<0){//如果输入的年龄数字大于120或者小于0,我们输出3
            this.age = 3; // || 或的意思,前后有一个为真就返回真,全false才返回false
        }else {
        this.age = age;
        }
    }
}

package com.oop.demo03;

import com.oop.demo04.Student;

public class Application {
    //进入了main方法
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("张三");

        System.out.println(s1.getName());//输入s1.getName().sout按回车 快捷键输出
        //输出:张三

        s1.setAge(-1);//在setAge方法里输入值-1,经过判断输出age=3
        System.out.println(s1.getAge());//输出3


    }
}
/*
封装的意义:
     1、提高程序的安全性,保护数据
     2、隐藏代码的实现细节,比如s1.setAge(-1);这里用户只能去设置括号里面的数,
        但类的方法里面的细节用户就不知道了
     3、统一接口  即所有的方法都是get和set,形成了一个规范
     4、提高系统的可维护性
     5、set方法里经常会对输入的数据进行一个安全性的判断,比如上边的setAge()
        方法,里面就有一个对用户输入的数值进行的一个大于120或小于0的判断
 */


P68 面向对象09:什么是继承

在这里插入图片描述

注意:PPT里的是extends,写错成了extands

下面四个程序是互动的,一个main程序Application,一个父类Person,两个子类Student和Teacher

//在这个main类里面 new 了Student的对象
package com.oop.demo05;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();
        System.out.println(student.money);

        Person person = new Person();
    }
}

//Person 总的类  是父类

//在Java中,所有的类,都默认继承Object类   ctrl+h打开等级列表显示当前类继承关系
package com.oop.demo05;

public class Person/* extends Object */ {

    //修饰符protected
    //修饰符public:公共的 如果想让子类继承父类数据就加public
    //修饰符private:私有的
    //修饰符default:默认的,即前边不加修饰符时 为这个状态

    public int money = 10_0000_0000;
    //这里用了public修饰符
    //如果父类用了private而不是public,则子类无法调用父类的方法


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

//派生类,相当于Person程序的子类
package com.oop.demo05;

//student is person  派生类,相当于Person程序的子类
//子类Student继承了父类Person,就会拥有父类Person的全部方法,可直接调用
public class Student extends Person {//在public class Student后
    //加了extends Person 就成为了Person的子类,就是继承了Person类
}

//派生类,相当于Person程序的子类
package com.oop.demo05;

//派生类,相当于Person程序的子类
public class Teacher extends Person{
}



P69 面向对象10:Super详解

在这里插入图片描述

下面四个程序是互动的,一个main程序Application,一个父类Person,两个子类Student和Teacher

//在这个main类里面 new 了Student的对象
package com.oop.demo05;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.test("秦疆");
        /*输出:秦疆
               qinjiang
               kuangshen
         */
        student.test1();
        /*输出:Student
               Student
               Person


         */


    }
}

//派生类,相当于Person程序的子类
package com.oop.demo05;

//student is person  派生类,相当于Person程序的子类
//子类Student继承了父类Person,就会拥有父类Person的全部方法,可直接调用

public class Student extends Person {

    //这是个子类构造器
    public Student() {
        //这里有隐藏代码:调用了父类的无参构造

        super();//调用父类的构造器,必须要在子类构造器的第一行
        System.out.println("Student无参构造器执行了");
    }

    private String name = "qinjiang";

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

    public void test1(){
        print();
        this.print();
        super.print();//表示调用的父类Person里的print方法
    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);//表示输出父类Person里的name
    }

}

//Person 总的类  是父类

//在Java中,所有的类,都默认继承Object类   ctrl+h打开等级列表显示当前类继承关系
package com.oop.demo05;

public class Person/* extends Object */ {

    //这是个父类构造器
    public Person() {
        System.out.println("Person无参构造器执行了");
    }

    protected String name = "kuangshen";

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

笔记

super注意点:
1、super调用父类的构造方法,必须在构造方法执行部分的第一行
2、super 必须只能出现在子类的方法或者构造方法中
(子类的构造方法中有一个隐藏的super调用了父类的构造方法)
3、super和 this 不能同时调用构造方法

super 比较 this:
代表的对象不同:
this:代表本身调用者这个对象
super:代表父类对象的应用
使用的前提:
this:没有继承也可以使用
super:只能在继承条件下才可以使用
调用构造方法的区别:
this():调用本类的构造
super():调用父类的构造



P70 面向对象11:方法重写

笔记:

重写override的前提:需要有继承关系,子类重写父类的方法。override有覆盖覆写的意思
重写的两个方法特点:
1.方法名必须相同
2.形参参数列表必须相同
3.修饰符:范围可以扩大但不能缩小: public>protected>default>private
4.抛出的异常:范围,可以被缩小,但不能扩大 ClassNotFoundException --> Exception(大)

重写,子类的方法名和父类必须一致,方法体不同

为什么需要重写:
1.父类的功能,子类不一定需要,或者不一定满足
alt+insert:选中override;

//在这个main类里面 new 了的对象
package com.oop.demo05;

public class Application {
    public static void main(String[] args) {

        //静态的方法和非静态的方法区别很大
        //加了static的静态方法:方法的调用只和等号左边的东西有关 ,左边定义的数据类型有关
        //非静态方法(不加static):重写
        //重写的方法的关键词不能是private
        //重写是子父类之家才有的,是子类重写(覆写)了父类的方法
        A a = new A();
        a.test();//
        //父类的引用指向了子类
        B b = new A();//子类A重写了父类的方法
        b.test();//

    }
}

package com.oop.demo05;

public class A extends B{

    @Override
    //注解:有功能的注释!  override重写,覆写的意思
    public void test() {
        System.out.println("A=>test()");
    }
}


package com.oop.demo05;

//重写都是方法的重写,和属性无关
public class B {

    public  void test(){
        System.out.println("B=>test()");
    }

}



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值