Java 入门之面向对象2

最新推荐文章于 2024-08-23 15:54:50 发布

养乐多妹妹

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量110

点赞数

分类专栏： LEARN 文章标签： java

本文链接：https://blog.csdn.net/weixin_41292239/article/details/104317209

版权

LEARN 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java重写和重载

重写是子类对父类允许访问的方法进行重新编写，返回值和形参不能变。
即外壳不变核心重写

方法重写的规则：
1.参数列表必须与被重写方法完全相同
2.返回值类型可以不同，但必须是父类方法返回值的派生类
3.访问权限不能比父类被重写的方法权限低
4.父类成员方法只能被子类成员重写
5，final方法不能被重写
6.static不能被重写，但可以被重新声明
7，构造方法不能被重写

当需要在子类中调用父类的被重写方法时，要用super关键字


```java
package java学习.重写和重载;

class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        super.move();//应用super类
        System.out.println("狗可以跑");
    }
}

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

        Animal a = new Animal();
        a.move();

        System.out.println();

        Dog c = new Dog();
        c.move();

        System.out.println();

        Animal b = new Dog();
        b.move();

    }
}

在这里插入图片描述
重载：是一个类里面，方法名字相同，参数不同，返回值不同
每个重载的方法必须有独一无二的参数列表
最常用的是构造器重载

重载的规则：
1.被重载的方法必须改变参数列表（个数或类型不一样）
2. 被重载的方法可以改变返回类型
3，被重载的方法可以改变访问修饰符
4，被重载的方法可以声明新的或更广的检查异常
5.方法能在一个类，或一个子类中被重载

package java学习.重写和重载;

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }

    public void test(int a){
        System.out.println("test2");
    }

    public String test(int a ,String s){
        System.out.println("test3");
        return "resulttest3";
    }

    public String test(String s,int a){
        System.out.println("test4");
        return "resulttest4";
    }

    public static void main(String[] args) {
        Overloading o = new Overloading();
        System.out.println(o.test());
        System.out.println();
        o.test(1);
        System.out.println();
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

在这里插入图片描述

Java多态

多态是：同一个行为有多个不同表现形式或形态
多态就是一个接口，使用不同实例执行不同操作

多态的优点：
1.消除类型之间的耦合关系
2.可替换性
3.可扩充性
4.接口性
5.灵活性
6.简化性
多态存在的三个必要条件：
1.继承
2.重写
3.父类引用指向之类对象 Parent p = new Child();

package java学习.多态;

public class Variety {
    public static void main(String[] args) {
        show(new Cat());
        show(new Dog());
        Animal a = new Cat();
        a.eat();
        Cat c = (Cat) a;
        c.work();

    }
    
    public static  void  show(Animal a) {
        a.eat();

        if (a instanceof Cat) {
            Cat c = (Cat) a;
            c.work();
        } else if (a instanceof Dog) {
            Dog c = (Dog) a;
            c.work();
        }
    }
    }
    abstract class Animal{
        abstract void eat();
    }
    
     class Cat extends  Animal{

        @Override
        public void eat() {
            System.out.println("吃鱼");
        }
        public void work(){
            System.out.println("抓老鼠");
        }
    }
     class Dog extends Animal{

        @Override
        void eat() {
            System.out.println("吃骨头");
        }
        public void work(){
            System.out.println("看门");
        }
    }

在这里插入图片描述

Java抽象类

抽象类不能实例化对象，所以抽象类必须被继承，才能使用。（因此在SEI阶段决定不要使用抽象类）
Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，但一个类可以实现多个接口

package java学习.抽象类;

public abstract  class Employee {
    private String name;
    private String address;
    private int number;
    public  Employee( String name,String address,int number){
        System.out.println("Constructing an Employee");
        this.name = name;
        this.address = address;
        this.number = number;
    }
    public double computePay(){
        System.out.println("Inside Employee computePay");
        return 0.0;
    }
    public void  mailCheck(){
        System.out.println("Email is check to " + this.name +" "+ this.address);
    }
    public  String toString (){
        return name+" "+address+" "+number;
    }

    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String newAddress) {
        address = newAddress;
    }

    public int getNumber() {
        return number;
    }
}

package java学习.抽象类;

public class Salary extends  Employee {
    private double salary;

    public Salary(String name, String address, int number,double salary) {
        super(name, address, number);
        setSalary(salary);
    }
    public void mainCheck(){
        System.out.println("Within mainCheck of Salary class ");
        System.out.println("Mailing check to " + getName()+ "with salary "+ salary);
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double newSalary) {
        if (newSalary>=0.0){
            salary = newSalary;
        }
    }

    public double computePay(){
        System.out.println("Computing salary pay for "+ getName());
        return  salary/52;
    }
}

package java学习.抽象类;

public class AbstractDemo {
    public static void main(String[] args) {
        //Employee e = new Employee("ZHANGYANA ","CAIHU",43) ;
        /**
         * 抽象类不可初始化
         */
        Salary s = new Salary("tt","usa",4,5300.00);
        Employee e = new Salary("张亚楠","美国",3,5300.00);
        System.out.println("Call mainCheck using Salary refercence --");
        s.mainCheck();

        System.out.println("\n  Call mainCheck using Empolyee refercence -- ");
        e.mailCheck();
    }
}

在这里插入图片描述

Java接口

接口是Java编程语言中的一个抽象类型，是抽象方法的集合。
一个类通过继承方法的方式，从而继承接口的抽象方法。

类描述对象的属性和方法
接口则包含类要实现的方法

除非实现接口的类是抽象类，否则该类要定义接口的所有方法。
接口不能实例化，但可以被实现。

Java中接口类型可以用来声明一个变量，他们可以成为一个空指针，或者是被绑定的在一个以此接口实现的对象

接口的实现

package java学习.接口;

public interface Animal {
    public void eat();
    public  void  travel();

}

package java学习.接口;

public class MammalInt  implements Animal{
    @Override
    public void eat() {
        System.out.println("Mammal eats");
    }

    @Override
    public void travel() {
        System.out.println("Mannal travel");
    }

    public int noOfLegs(){
        return 0;
    }

    public static void main(String[] args) {
        MammalInt m = new MammalInt();
        m.eat();
        m.travel();

    }

}

接口的继承

package java学习.接口;

public interface Sports {
    public void setHomeTeam(String name);
    public void setVisitingTeam(String name);
}

package java学习.接口;

public interface Football extends Sports {
    public  void  homeTeamScored(int points);
    public void visitingTeameScored(int points);
    public void endOdQuarter(int quater);
}

package java学习.接口;

import org.w3c.dom.events.Event;

public interface Hockey extends Sports, Event {//接口允许多继承，类不允许多继承
    public void homeGoalScored();
    public void visitingGoalScored();
    public void endOfPeriod(int period);
    public void overtimePeriod(int ot);
}

标记接口

package java学习.接口;

public interface EventListener {
/**
 * 没有任何方法的接口称为标记接口
 * 建立标记接口的目的：
 * 1、建立公共的父接口
 * 2、向一个类添加数据类型
 */
}

养乐多妹妹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 入门之面向对象2

Java重写和重载重写是子类对父类允许访问的方法进行重新编写，返回值和形参不能变。即外壳不变核心重写方法重写的规则：1.参数列表必须与被重写方法完全相同2.返回值类型可以不同，但必须是父类方法返回值的派生类3.访问权限不能比父类被重写的方法权限低4.父类成员方法只能被子类成员重写5，final方法不能被重写6.static不能被重写，但可以被重新声明7，构造方法不能被重写当...
复制链接

扫一扫