【JAVA】part2-Java面向对象

曾经``沧海

已于 2024-04-25 12:35:26 修改

阅读量691

点赞数 20

分类专栏： Java language 文章标签： java 开发语言

于 2024-04-25 12:31:09 首次发布

本文链接：https://blog.csdn.net/kx_52517/article/details/138185444

版权

Java language 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

part2-Java面向对象

请添加图片描述

面向对象编程

Oop.java

/*
 * 在学习完part2-Java面向对象后，可以轻易的读懂下方代码
 * 什么是 类，对象，封装，继承,抽象(demo以接口interface为例)
 * 什么是方法重载(demo以构造方法为例)，静态变量，静态方法
 */
public class Oop {
    public static void main(String[] args) {
        Person p = new Person("Kyle Wang", 23);
        System.out.println(p.getName());
        System.out.println(p.getAge());
        System.out.println();
        Man m = new Man("Maddy Li", 22 , 164);
        System.out.println(m.getName());
        System.out.println(m.getAge());
        System.out.println(m.getHeight());
        m.drinkWater();
        m.eatFood();
        Person.classCode = 100;
        System.out.println(Man.classCode);
        System.out.println(Man.calculateAbs(-1000));;
    }
}
interface Action {
    void drinkWater();
    void eatFood();
}


class Person{
    public static int classCode = 10;

    private String name;
    private int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void setNmae(String name) {
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }

    public static int calculateAbs(int x){
        return x<0 ? -x : x;
    }
}

class Man extends Person implements Action{
    private double height;
    public Man(){

    }

    public Man(String name,int age,double height){
        super(name, age);
        this.height = height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
    public double getHeight(){
        return this.height;
    }

    @Override
    public void drinkWater() {
        System.out.println(this.getName()+ " wants to drink water.");
    }

    @Override
    public void eatFood() {
        System.out.println(this.getName()+ " wants to eat food.");
    }

}

封装（Encapsulation）

关键字：private，protected

继承（Inheritance）

关键字：extends

多态（Polymorphism）

PolymorphismIntro.java

注解：@Override

多态存在的三个必要条件
继承
重写
父类引用指向子类对象：Parent p = new Child();

public class PolymorphismIntro {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 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 {  
    public void eat() {  
        System.out.println("eat fish");  
    }  
    public void work() {  
        System.out.println("catch mouse");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("eat bone");  
    }  
    public void work() {  
        System.out.println("protect home");  
    }  
}

接口（Interface）

InterfaceIntro.java

目的：主要用来定义一个合同，它规定了可以做什么，而不涉及具体如何做。接口是定义行为的规范。

与类的区别：类描述对象的属性和方法。接口则包含类要实现的方法。
与抽象类的区别：一个类只能继承一个抽象类，却可以实现多个接口。

关键字：interface，implements

public class InterfaceIntro {
    public static void main(String args[]) {
        Mammal m = new Mammal();
        Bird b = new Bird();

        m.eat();
        m.travel();
        System.out.println("Mammal has " + m.noOfLegs() + " legs.");

        b.eat();
        b.travel();
        System.out.println("Does bird lay eggs? " + b.laysEggs());
    }
}


// 定义一个接口
interface Animal {
    // 接口里的方法是抽象的，没有方法体
    void eat();
    void travel();
}

// 实现Animal接口的Mammal类
class Mammal implements Animal {
    // 实现接口中的方法
    @Override
    public void eat() {
        System.out.println("Mammal eats");
    }
    @Override
    public void travel() {
        System.out.println("Mammal travels");
    }

    // Mammal类自己的方法
    public int noOfLegs() {
        return 4;
    }
}

// 实现Animal接口的Bird类
class Bird implements Animal {
    // 实现接口中的方法
    @Override
    public void eat() {
        System.out.println("Bird eats");
    }
    @Override
    public void travel() {
        System.out.println("Bird flies");
    }

    // Bird类自己的方法
    public boolean laysEggs() {
        return true;
    }
}

抽象类（Abstraction）

AbstractClass.java

目的：主要用来捕捉子类的通用特性，它可以包含实现代码（除抽象方法外）。抽象类是表示一个事物的本质。

特性：自身抽象，所以不能实例化对象，必须被继承；抽象方法不能有具体实现，所以抽象方法必须被实现

关键字：abstract class

public  class AbstractClass{
    public static void main(String[] args) {
        //但是如果我们实例化一个 Salary 类对象，该对象将从 Employee 类继承 7 个成员方法和三个成员变量
        Salary s = new Salary("Kyle", "henu", 20242301, 9600.00);
        Employee e = new Salary("John", "zzu", 20242302, 4600.00);

        System.out.println("Call mailCheck using Salary reference --");
        s.mailCheck();

        System.out.println("\n Call mailCheck using Employee reference--");
        e.mailCheck();
    }
}

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("Mailing a 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;
    }
}


class Salary extends Employee{
    private double salary;
    public Salary(String name,String address,int number,double salary){
        super(name, address, number);
        setSalary(salary);

    }
    private void setSalary(double salary) {
        if(salary >= 0.0)
       {
          this.salary = salary;
       }
    }
    public double computePay()
    {
       System.out.println("Computing salary pay for " + getName());
       return salary/52;
    }
}

枚举类（enum）

EnumIntro.java
Java枚举类：它提供了一种类型安全的方式来定义一组常量，使得代码更加的易于维护和理解。

enum Day {  //Day 是一个枚举类型，它有七个枚举常量，代表一周的七天。
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

public class EnumIntro {
    Day day;
    public EnumIntro(Day day) {
        this.day = day;
    }

    public void tellItLikeItIs() {
        switch (day) {
            case MONDAY:
                System.out.println("Mondays are bad.");
                break;
                
            case FRIDAY:
                System.out.println("Fridays are better.");
                break;
                
            case SATURDAY:
            case SUNDAY:
                System.out.println("Weekends are best.");
                break;
                
            default:
                System.out.println("Midweek days are so-so.");
                break;
        }
    }

    public static void main(String[] args) {
        EnumIntro firstDay = new EnumIntro(Day.MONDAY);
        firstDay.tellItLikeItIs();
        EnumIntro thirdDay = new EnumIntro(Day.WEDNESDAY);
        thirdDay.tellItLikeItIs();
        EnumIntro fifthDay = new EnumIntro(Day.FRIDAY);
        fifthDay.tellItLikeItIs();
        EnumIntro sixthDay = new EnumIntro(Day.SATURDAY);
        sixthDay.tellItLikeItIs();
        EnumIntro seventhDay = new EnumIntro(Day.SUNDAY);
        seventhDay.tellItLikeItIs();
    }
}

包（Package）

PackageSource.java 定义了一个接口并打包
PackageIntro.java 使用它这个被打包的接口

interface PackageSource {
    public void eat();
    public void travel();
}

public class PackageIntro implements PackageSource {

    @Override
    public void eat() {
        System.out.println("Eats");
    }

    @Override
    public void travel() {
        System.out.println("Travels");
    }
    
    public static void main(String[] args) {
        PackageIntro p = new PackageIntro();
        p.eat();
        p.travel();
    }
}