面向对象进阶！

面向对象进阶！

1.1 继承！

多个类中存在相同属性和行为是，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只需要继承即可.

1.此处的多个类称为子类，单独的这个类称为父类，extends。

2.子类继承了父类，也继承了父类的方法和属性！

3.子类中可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

4.继承的关键字为exteds，子类不是父类的子集，而是父类的扩展。

5.子类不可以访问父类的私有（private）方法和成员变量。

6.java只支持单继承和多层继承，不允许多层继承。

 

public class Student extends Person{

private String major;

    public Student() {
    }

    public Student(String major) {
        this.major = major;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public void show(){
        System.out.println("姓名："+super.getName()+"年龄："+super.getAge()+"专业："+major);
    }

    public void study(){
show();
        System.out.println("学员在学习呢");
    }
}

public class Test {
    public static void main(String[] args) {
        Creature c = new Creature();
        c.breath();

//
        Person p = new Person();
        p.breath();
        p.setName("库里");
        p.setAge(34);
        p.eat();
        p.sleep();

        System.out.println("----------------------------");

        Student s = new Student("java");
//        s.breath();
        s.setName("汤普森");
        s.setAge(30);
        s.eat();
        s.sleep();
        s.show();
        s.study();
    }
}

以上是继承经典案例（以后复习看）

1.2 重写

方法重写指的是在子类中重写（覆盖）父类的方法。子类可以根据自身的需求重新实现继承自父类的方法，但方法名、参数列表和返回值类型必须与父类中被重写的方法保持一致。

在子类中可以根据需要对从父类继承来的方法进行改造，也成为方法的覆盖、重置

override/overwrite 在程序执行时，子类的方法将覆盖父类的方法

1.子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2.子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

3.子类重写的方法是使用的访问权限不能小于父类被重写的方法的访问权限

子类不可以重写父类中private权限的方法

4.子类抛出的异常不能大于父类被重写方法的异常

1.3 修饰符

private： 当前类    default：当前包可以访问 

pritected： 子类可以访问  super.protected 变量（方法）可以访问

public： 所有工程可以访问

案例：

public class ModifierParent {  //修饰符

    private int b;
    int a ; //default
    protected int c;
    public int d;

    private void f2(){
        System.out.println("f2"+b);
    }
    void f1(){
        System.out.println("f1");
    }
    protected void f3(){
        System.out.println("f3");
    }
    public void f4(){
        System.out.println("f4");
    }
}

public class ModifierChildren1 extends ModifierParent{

    public  void f5(){
        ModifierParent p = new ModifierParent();

        //不能访问私有变量
//        new ModifierParent().b; //不能访问其他类的私有变量
//        new ModifierParent().f2;//不能访问其他类的private

//        2.不带修饰符，包内可以访问  default
        System.out.println(p.a);
        System.out.println(super.a); //访问父类的变量
        p.f1(); //访问父类方法

        //3.protecter（类，包，子类）包可见！以及子类可见
        //同包下两个类不具有继承关系，也可以访问
        System.out.println(p.c);
        System.out.println(super.c);
        f3();

        //3.public 公共
        System.out.println(p.d);
        System.out.println(super.d);
        f4();

        System.out.println("f5");
    }
}

1.不可以方位其他类的私有变量  ：private

2.default 当前包内可访问

3.protected  当前包可访问，子类也可以访问，同包下不继承也可访问

4.public 公共

1.4 super和this

 this： 访问本类中的属性，如果没有则从父类中继续查找          super：直接访问父类中的属性

          访问本类中的方法，如果没有则从父类中继续查找                        直接访问父类中的方法

          调用本类构造器，必须放在构造器的首行       调用父类构造器，必须放在子类构造器首行     

super 实际应用案例

this 实际应用

 父类定义了一个int num = 20

1.5 多态 

https://wenku.baidu.com/view/d5c20effcd2f0066f5335a8102d276a2002960b6.html?fr=sogou&_wkts_=1690891359864

关于多态：

• 多态性，是面向对象中最重要的概念， 在Java中的体现：对象的多态性：父类的引用指向子类的对象
• Java引用变量有两个类型： 编译时类型和运行时类型。 编译时类型由声明该变量时使用的类型决定， 运行时类型由实际赋给该变量的对象决定。 简称： 编译时， 看左边；运行时， 看右边。

• • 若编译时类型和运行时类型不一致， 就出现了对象的多态性(Polymorphism)
  • 多态情况下， “看左边” ： 看的是父类的引用（父类中不具备子类特有的方法）“看右边” ： 看的是子类的对象（实际运行的是子类重写父类的方法）

• 多态，提高了代码的通用性，常称作接口重用

编译看左边，运行看右边。 2.父类Animal 的变量 ，new的是Dog，也可以new Animal的其他子类，这种称为多态。

1.6 object类

== 比较内存地址

equals（Object obj）：比较内容，但是默认比较内存地址

toString：将对象转换为字符串表示，他是一个非常常用的方法，通常会被子类重写以返回有意义的字符串表示

getClass（）：返回对象的运行时类，可以使用该方法获取对象所属的类

1.7  包装类、自动装箱和拆箱

1.7.1包装类：

在 Java 的设计中提倡一种思想，即一切皆对象。但是从数据类型的划分中，我们知道 Java 中的数据类型分为基本数据类型和引用数据类型，但是基本数据类型怎么能够称为对象呢？于是 Java 为每种基本数据类型分别设计了对应的类，称之为包装类（Wrapper Classes）

、

1.7.2 装箱和拆箱：

基本数据类型转换为包装类的过程称为装箱，例如把 int 包装成 Integer 类的对象；包装类变为基本数据类型的过程称为拆箱，例如把 Integer 类的对象重新简化为 int。

public class Together {  //自动装箱和拆箱

    public static void main(String[] args) {
        int m = 500;
        Integer obj = m; //自动装箱
        int n = obj; //自动拆箱
        System.out.println("n = " +n);
        System.out.println("obj = "+obj);
        System.out.println(m);

        Integer obj1 = 500;
        System.out.println("obj等价于obj1返回结果为： "+obj.equals(obj1));
        System.out.println("----------------------------------------");


        //包装类的应用： int & integer
        int a = 500;
        Integer obj2 = new Integer(a); //手动装箱
        int b = obj2.intValue(); //手动拆箱
        System.out.println(b);
        System.out.println(obj2);

        // 2.String转int
        String str1 = "30";
        String str2 = "30.3";
        //将字符串变成int类型
        int c = Integer.parseInt(str1);
        float d = Float.parseFloat(str2);
        System.out.println("c = "+c+"  "+"d =  "+d);

        //3.int转String
        int e = 500;
        String f = Integer.toString(e);
        System.out.println(f);
    }
}