java5.面向对象编程(中)

最新推荐文章于 2022-03-15 22:33:30 发布
最新推荐文章于 2022-03-15 22:33:30 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： Java基础 文章标签： 多态 java 封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slslslslslsls/article/details/117827767
版权
本文详细介绍了Java中的继承特性，包括继承的作用、规则、方法重写、访问权限修饰符、super关键字的使用以及多态性的概念。示例代码展示了如何创建类的继承关系，如何调用父类方法，以及在子类中实现方法重写。同时，讨论了对象的多态行为及其在实际编程中的应用。
摘要由CSDN通过智能技术生成

5.1继承性

class Person{
    private String name;
    private int age;
    private Date birthDate;
    public String getInfo(){
        return "Person";
    }
}

class Student extends Person{
    public String school;
    @Override
    public String getInfo() {
        return super.getInfo() + "Student";
    }
}
// Student类继承了父类Person的所有属性和方法，并增加了一
//个属性school。Person中的属性和方法,Student都可以使用

在这里插入图片描述

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

作用：
		 继承的出现减少了代码冗余，提高了代码的复用性。
		 继承的出现，更有利于功能的扩展。
		 继承的出现让类与类之间产生了关系，提供了多态的前提。
		注意：不要仅为了获取其他类中某个功能而去继承

 子类继承了父类，就继承了父类的方法和属性。
 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和
方法。
 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

关于继承的规则：
子类不能直接访问父类中私有的(private)的成员变量和方法。
不能访问的原因:私有属性,方法只可以本类中调用

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

public class test1 {
    public static void main(String[] args) {
        Student1 student1 = new Student1();
        System.out.println(student1.aver());

    }
}
class Person1{
    private String name;
    private char sex;
    private int age;
    public Person1(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public Person1() {
    }
    @Override
    public String toString() {
        return "Person1{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}
class Student1 extends Person1{
    private long number;
    private int math;
    private int english;
    private int computer;
    public Student1() {
    }
    public Student1(String name, char sex, int age, long number, int math, int english, int computer) {
        super(name, sex, age);
        this.number = number;
        this.math = math;
        this.english = english;
        this.computer = computer;
    }
    @Override
    public String toString() {
        return "Student1{" +
                "number=" + number +
                ", math=" + math +
                ", english=" + english +
                ", computer=" + computer +
                "} " + super.toString();
    }
    public double aver(){
        return 0.2;
    }
    public int max(){
        return 1;
    }
    public int min(){
        return 2;
    }
}

在这里插入图片描述

package classTest3;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-22:52
 */
public class test2 {
    public static void main(String[] args) {
        Kids kids = new Kids();
        kids.sex = 1;
        kids.maxOrWoman();
    }
}
class ManKind{
    int sex;
    private int salary;
    public void maxOrWoman(){
        if (sex == 1){
            System.out.println("man");
        }else if (sex == 0){
            System.out.println("woman");
        }else {
            System.out.println("输入错误");
        }
    }
    public void employee(){
        if (salary == 0){
            System.out.println("no job");
        }else {
            System.out.println("job");
        }
    }

}
class Kids extends ManKind{
    private int yearsOld;
    public void printAge(){
        System.out.println(yearsOld);
    }
}

在这里插入图片描述

package classTest3;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-23:56
 */
public class test3 {
    public static void main(String[] args) {
        Cylinder cylinder = new Cylinder();
        System.out.println(cylinder.findVolume());
    }
}
class Circle{
    private double radius;

    public Circle() {
        this.radius = 1;
    }

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }
}
class Cylinder extends Circle{
    private double length;

    public Cylinder() {
        this.length = 1;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }
    public double findVolume(){
        return Math.PI * getRadius() * getLength() * length;
    }
}

5.2方法的重写
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？(NO):子类不能重写父类中声明为private的方法;子类重写方法的访问权限不能小于父类,返回值类型不能大于父类

5.3四种访问权限修饰符
在这里插入图片描述
在这里插入图片描述
5.4关键字super

在Java类中使用super来调用父类中的指定操作：
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器 注意：
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
super的追溯不仅限于直接父类 super和this的用法相像，this代表本类对象的引用，super代表父类的内存
空间的标识

package classTest3;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-0:45
 */
public class test4 {
    public static void main(String[] args) {
        Student student = new Student();
        String info = student.getInfo();
        System.out.println(info);

    }
}
class Person{
    protected String name = "张三";
    protected int age;
    public String getInfo(){
        return "name: " + name + "\nage:" + age;
    }
}
class Student extends Person{
    protected String name = "李四";
    private String school = "New Oriental";
    public String getSchool(){
        return school;
    }
    public String getInfo(){
        return super.getInfo() + "\nschool: " + school;
    }
}

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

public class Person {
	private String name;
	private int age;
	private Date birthDate;
	public Person(String name, int age, Date d) {
	this.name = name;
	this.age = age;
	this.birthDate = d; }
	public Person(String name, int age) {
	this(name, age, null);
	}
	public Person(String name, Date d) {
	this(name, 30, d);
	}
	public Person(String name) {
	this(name, 30);
} }

public class Student extends Person {
	private String school;
	public Student(String name, int age, String s) {
	super(name, age);
	school = s; 
	}
	public Student(String name, String s) {
	super(name);
	school = s; 
	}
	// 编译出错: no super(),**系统将调用父类无参数的构造器**。
	public Student(String s) { 
	school = s; 
} }

在这里插入图片描述
1).为什么super(…)和this(…)调用语句不能同时在一个构造器中出现？
因为这样会调用两次父类
2).为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现？
必须在构造器的第一行放置super或者this构造器，否则编译器会自动地放一个空参数的super构造器的
在这里插入图片描述
在这里插入图片描述

package classTest3;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-0:58
 */
public class test5 {
}
class Creature {
    public Creature() {
        System.out.println("Creature无参数的构造器");
    }}
class Animal extends Creature {
    public Animal(String name) {
        System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
    }
    public Animal(String name, int age) {
        this(name);
        System.out.println("Animal带两个参数的构造器，其age为" + age);
    }}
class Wolf extends Animal {
    public Wolf() {
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args) {
        new Wolf();
    }}

由父即子
在这里插入图片描述
5.6多态性:编译时:看左边,运行时:看右边
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class ConversionTest {
public static void main(String[] args) {
double d = 13.4;
long l = (long) d;
System.out.println(l);
int in = 5;
// boolean b = (boolean)in;
Object obj = "Hello";
String objStr = (String) obj;
System.out.println(objStr);
Object objPri = new Integer(5);
// 所以下面代码运行时引发ClassCastException异常
//对象与对象之间要有继承关系
String str = (String) objPri; } }

在这里插入图片描述

class Base {
int count = 10;
public void display() {
System.out.println(this.count);
} }
class Sub extends Base {
int count = 20;
public void display() {
System.out.println(this.count);
} }
public class FieldMethodTest {
public static void main(String[] args){
Sub s = new Sub();
System.out.println(s.count);
s.display();
Base b = s;//子类父类中都有count这个属性,所以子类中的count也可以通过多态获取,编译时父类中有count,所以可以访问,只是不能访问子类中添加的属性和方法
System.out.println(b == s);
System.out.println(b.count);
b.display();
} }

在这里插入图片描述
在这里插入图片描述
如果是person类,说明他只是person类的子类,只输出一个
如果是graduate的话,他是三个类的子类

package classTest3;

import java.lang.reflect.Method;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-1:28
 */
public class test7 {
    public void method(Person2 per){
        if (per instanceof Graduate2){
            System.out.println("a Graduate");
        }
        if (per instanceof Student2){
            System.out.println("a student");
        }
        if (per instanceof Person2){
            System.out.println("a Person");
        }
    }
    public static void main(String[] args) {
        test7 test7 = new test7();
        test7.method(new Student2());
    }
}
class Person2 {
protected String name="person";
protected int age=50;
public String getInfo() {
return "Name: "+ name + "\n" +"age: "+ age;}
}
class Student2 extends Person2 {
protected String school="pku";
public String getInfo() {
return "Name: "+ name + "\nage: "+ age
+ "\nschool: "+ school;
} }
class Graduate2 extends Student2{
 public String major="IT";
 public String getInfo()
 {  return "Name: "+ name + "\nage: "+ age
 + "\nschool: "+ school+"\nmajor:"+major;
 }  }

在这里插入图片描述
随机的三个子类,发现每次多态结果都不一样

5.7Object类的使用
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package classTest3;

import java.util.Objects;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-1:47
 */
public class test8 {
    public static void main(String[] args) {
        Order order = new Order(14,"23");
        Order order1 = new Order(14,"23");
        System.out.println(order.equals(order1));
    }
}
class Order{
    int orderId;
    String orderName;

    public int getOrderId() {
        return orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Order(int orderId, String orderName) {
        this.orderId = orderId;
        this.orderName = orderName;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Order order = (Order) o;
        return orderId == order.orderId &&
                Objects.equals(orderName, order.orderName);
    }


}

toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址
在这里插入图片描述

public void test() {
char[] arr = new char[] { 'a', 'b', 'c' };
System.out.println(arr);//
int[] arr1 = new int[] { 1, 2, 3 };
System.out.println(arr1);//
double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
System.out.println(arr2);//
}
char重写了print
public void println(char x[]) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

在这里插入图片描述


package classTest3;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-1:59
 */
public class test10 {
    p


ublic static void main(String[] args) {
        Circle1 circle1 = new Circle1("ds0",45,45);
        Circle1 circle2 = new Circle1(45);
        System.out.println(circle1.equals(circle2));
    }
}
class GeometricObject{
    protected String color;
    protected double weight;

    public GeometricObject() {
        this.color = "weight";
        this.weight = 1.0;
    }

    public GeometricObject(String color, double weight) {
        this.color = color;
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public double getWeight() {
        return weight;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}

class Circle1 extends GeometricObject{
    private double radius;
    public Circle1() {
    }

    public Circle1(double radius) {
        this.radius = radius;
    }

    public Circle1(String color, double weight, double radius) {
        super(color, weight);
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this){return true;}
        if (obj == null || this.getClass() != obj.getClass()){
            return false;
        }
        Circle1 circle1 = (Circle1) obj;
        return this.radius == circle1.radius;
    }
}

5.8包装类
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
会有不同,三元运算符会自动转型,变为double

public void method1() {
	Integer i = new Integer(1);
	Integer j = new Integer(1);
	System.out.println(i == j);//false
	Integer m = 1;
	Integer n = 1;
	System.out.println(m == n);//true:在-127-127有一个存储
	Integer x = 128;
	Integer y = 128;
	System.out.println(x == y);//false
}

在这里插入图片描述

package classTest3;

import java.util.Scanner;
import java.util.Vector;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-2:14
 */
public class test11 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Vector vector = new Vector();
        boolean isFlag = true;
        while (isFlag){
            System.out.println("请输入学生的成绩");
            int num = scanner.nextInt();
            if (num >= 0){ vector.addElement(new Integer(num));}
            else {isFlag = false;}
        }
        int max = 0;
        for (int i = 0; i < vector.size(); i++){
            if ((int)vector.elementAt(i) > max){
                max = (int)vector.elementAt(i);
            }
        }
        for (int i = 0; i < vector.size(); i++){
            if (max - (int)vector.elementAt(i) < 10){
                System.out.println("student" + i + " is A");
            }else if (max - (int)vector.elementAt(i) < 20){
                System.out.println("student" + i + " is B");
            }else if (max - (int)vector.elementAt(i) < 80){
                System.out.println("student" + i + " is S");
            }
        }
    }
}
漂酿男骸
关注
专栏目录
JAVA基础（十）
m0_56413004的博客
08-01 1031
debug，方法的重写，super，多态性（虚拟方法调用）
第五章 面向对象（中）
qq_42082278的博客
07-09 1086
一、OOP特征二：继承性 二、方法的重写(override) 三、四种访问权限修饰符 四、关键字：super 五、 子类对象实例化过程 六、OOP特征三：多态性 七、Object类的使用 八、包装类的使用
Object类的练习（equals,toString）
qq_37636795的博客
02-22 330
1.Object 类的使用 int it = 65; float fl = 65.0f; System.out.println(“65和65.0f是否相等？” + (it == fl)); //1 char ch1 = 'A'; char ch2 = 12; System.out.println("65和'A'是否相等？" + (it == ch1));//2 System.out.println(“12和ch2是否相等？" + (12 == ch2));//3 String str1 = new St
java基础_打印字符数组输出字符串
Sharpen__的博客
03-09 4822
java打印字符数组 示例代码 class temp{ public void test() { char[] arr = new char[] { 'a', 'b', 'c' }; System.out.println(arr);// int[] arr1 = new int[] { 1, 2, 3 }; System.out.println(arr1);// double...
Jvava面试题（ “==” 和equals（）的区别）
weixin_45661472的博客
03-15 470
一、“==” 的使用 1.== 是一个运算符 既可以使用在基本数据类型变量，又可以使用于引用数据类型变量中，对于基本类型就是比较值（不一定类型要相同），对于引用类型就是比较内存地址，即两个引用是否指向同一实体 二、equals（）方法 1.是一个方法，而非运算符 2.只适用于引用数据类型 3.Object类中equals()的定义 public boolean equals(Object obj) { return ...
java面向对象编程pdf
04-16
在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在...
漫画面向对象编程 Java
06-16
借助于漫画展示的形式，面向对象的简、由类创建一个对象的方法、类的编写与对象的创建、类的构造函数、类的方法、修饰符、... 可以在轻松幽默的氛围中对面向对象编程产生浓厚的兴趣，从而为后续的编程进阶树立信心。
Java面向对象编程思想.pdf
07-14
Java面向对象编程思想 Java 面向对象编程思想是 Java 编程语言的核心思想之一，通过封装、继承和多态三个特征，实现代码的重用和可维护性。 一、封装 封装是 Java 面向对象编程的三大特征之一，通过 Java 的类来...
第5章-JAVA面向对象编程基础.ppt
最新发布
11-21
JAVA面向对象编程基础 JAVA面向对象编程是面向对象编程语言的基础，包含定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等内容。 一、定义类 在JAVA中，定义类使用class关键字，语法...
java第05章.面向对象编程-1.pdf
07-30
java第05章.面向对象编程-1.pdf
子类不能继承或覆盖父类的private方法
jump_tigris的博客
07-31 2200
题目：如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？ 答：不是。因为private关键字的定义是“除了包含该成员的类之外,其他任何类都无法访问这个成员.”，也就是说只有自己才能直接访问到private成员，其他任何类，包括子类都无法访问到这个成员。 我们可以来写两个类测试一下： 1.先写一个正常的重写方法 public cla...
Java中如果父类方法使用private定义，子类使用public 覆写，是否正确？
我是扣肉呀~
02-25 3344
看以下代码：父类使用private定义的方法，子类使用public覆写： class Father{ public void fun(){ this.print(); } //如果现在父类使用了private定义，那么就表示该方法只能被父类使用，子类无法使用，换句话说，子类是不知道父类有这样的方法的。 private void print()...
java易错笔试题_面试易错题 Java
weixin_33160876的博客
02-26 359
1.int[] arr = new int[10]; System.out.println(arr);//地址值?char[] arr1 = new char[10]; System.out.println(arr1); //地址值?测试：public class ArrayPrintTest {public static void main(String[] args) {int[] arr =...
直接输出数组的引用，char[]的例外情况
CmdSmith的博客
01-10 3411
import java.util.Arrays; public class TestArray { public static void main(String[] args) { char[] arr1 = new char[] {'a', 'b', 'c'}; System.out.println(arr1); System.out.println(Arrays.toStr
char数组的println输出
weixin_44878335的博客
06-30 1212
package com.atczh1.java; public class ArraysTest { public static void main(String[] args) { int[] arr=new int[] {1,2,3}; System.out.println(arr); char[] arr1=new char[] {'a','b','c'}; System.out.println(arr1); } } 分别是int，c.
最简单的面试题之数组问题(但是大多数人都会做错)
nicecode
04-20 335
问题:如下代码所示,请问输出结果是什么? int[] arr1 = new int[]{1,2,3}; System.out.println(arr1); char[] arr2 = new char[]{'a','b','c'}; System.out.println(arr2); 或许大多数人都认为这也太简单了吧! 心想结果不就是输出的...
Java第七天学习（高级类特性1）
hu_xiao_hei的博客
05-07 1031
高级类特性 面向对象特征之二：继承 为描述和处理个人信息，定义Person： person| |–| +name:String ;+age:int| +getInfo():String| public class Person{ public String name; public int age; public String getInfo(){ … } } 方法的重写（ov...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值