面向对象进阶

已于 2023-11-20 20:06:27 修改
阅读量42 收藏
点赞数
文章标签： java 开发语言
于 2023-11-10 07:57:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AYTOY/article/details/134298332
版权

目录

1.static

(1)静态变量

（2）静态方法

（3）static注意事项

2.继承

（1）什么是继承？继承的好处

（2）继承的特点

(3)子类可以继承父类的哪些内容

（4）继承中成员变量与成员方法的的访问特点

（5）继承中：构造方法的访问特点

（6）this super 使用总结

3.多态 

（1）多态的基本认识

（2）多态调用成员的特点

（3）多态的优势和弊端

1.static
(1)静态变量

60540aa56ec443c4a353e34079a954ca.png

5622b2dd7f5e4d558cd0dcd18acb7a1c.png

public class staticDemo1 {
    private String name;
    private  int age;
    private  String gender;
   public static  String teachername;
    public staticDemo1() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    public  void study(){
        System.out.println(name+"正在学习");
    }
    public  void show(){
        System.out.println(name+","+age+","+gender+","+teachername);
    }
}

public class staticDemo1Test {
    public static void main(String[] args) {
        staticDemo1.teachername = "阿伟老师";
        staticDemo1 s1 = new staticDemo1();
        staticDemo1 s2 = new staticDemo1();
        s1.setName("张三");
        s1.setAge(18);
        s1.setGender("女");

        s1.study();
        s1.show();
       System.out.println("-------------");
        s2.setName("李四");
        s2.setAge(20);
        s2.setGender("女");

        s2.study();
        s2.show();
    }
}

dca78b37945f487ab5f6338889656d96.png

静态变量是随着类的加载而加载的，优先于对象的出现；

28bda767cf2b44bab9a22623c3267201.png

（2）静态方法

public class ArrayUtil {
    //    私有化构造方法
//    目的：不让外界创建他的对象
    private ArrayUtil() {
    }

    //需要定义为静态的方法调用
    public static String printArr(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append((arr[i]));
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
    public static double getAverage(double[] arr){
        double sum = 0;
        for (int i = 0; i < arr.length ; i++) {
            sum = sum+arr[i];
        }
        return sum/arr.length;
    }
}
public class ArrayUtilTest {
    public static void main(String[] args) {
//        测试两个工具类的方法是否成功
        int[] arr1 = {1,2,3,4,5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);


        double[] arr2 ={1.5,3.7,4.9,5.8,6.6};
        double avg = ArrayUtil.getAverage(arr2);
        System.out.println(avg);
    }
}
（3）static注意事项

2.继承
（1）什么是继承？继承的好处

（2）继承的特点

package Demo1;

public class Animal {
    public void eat(){
        System.out.println("在吃东西");
    }
    public void drank(){
        System.out.println("在喝水");
    }
}


package Demo1;

public class cat extends Animal{
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }
}

package Demo1;

public class buOu extends cat{

}

package Demo1;

public class Husky extends dog{

    public void breakHome(){
        System.out.println("在拆家");
    }
}
package Demo1;

public class Test {
    public static void main(String[] args) {
//        创建对象并调用方法

//        1.创建布偶猫的对象
        buOu rd = new buOu();
        rd.eat();
        rd.catchMouse();
        rd.drank();
      System.out.println("-----------------");
//        2.创建哈士奇的对象
        Husky h = new Husky();
        h.breakHome();
        h.drank();
        h.eat();
    }
}

 

(3)子类可以继承父类的哪些内容

 子类中的所有成员变量都可以继承下来，但是被private修饰的成员变量不能被直接调用，需要javabean

虚方法：不被final,private,static等修饰的方法

（4）继承中成员变量与成员方法的的访问特点

成员变量:

成员方法:

package Demo2;

public class Dogs {
    public void eat(){
        System.out.println("狗在吃狗粮");
    }
    public void lookHome(){
        System.out.println("狗在看家");
    }
}





public class Husky extends Dogs {
    public void breakhome(){
        System.out.println("哈士奇在拆家");
    }
}


public class ChineseDog extends Dogs {
    //    父类中的方法不能满足我们的需求了，所以需要进行重写
//    而且中华田园犬完全用不到父类中的代码，所以不需要通过super进行调用
    public void eat(){
        System.out.println("吃剩饭");
    }
}




public class SharPi extends Dogs {
//    因为沙皮狗吃的狗粮和骨头
//    父类中的方法不能满足我们的需求了，所以需要进行重写
    @Override
    public void eat(){
    super.eat();
//    调用父类的eat:吃狗粮
        System.out.println("狗啃骨头");
    }
}


public class Test {
    public static void main(String[] args) {
        Husky h = new Husky();
        h.eat();
        h.breakhome();
        h.lookHome();

        ChineseDog c = new ChineseDog();
        c.eat();
        c.lookHome();

    }
}

（5）继承中：构造方法的访问特点

父类中的构造方法不会被子类继承

（6）this super 使用总结

public class students {
    private  String name;
    private   int age;
    private  String bj;
    private  String num;

    public students() {
//        需求：默认为18岁
        this(null,18,null,null);
        System.out.println("我是学生"+age+"岁了");
    }

package Demo3;

public class Employee {
    private String id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void work(){
        System.out.println("员工在工作");
    }
    public void eat(){
        System.out.println("在吃饭");
    }
}

package Demo3;

public class Manager extends Employee{
    private  double bouns;
//空参构造
    public Manager() {

    }
//带全部参数的构造
// 父类加子类
    public Manager(String id, String name, double salary, double bouns) {
        super(id, name, salary);
        this.bouns = bouns;
    }

    public double getBouns() {
        return bouns;
    }

    public void setBouns(double bouns) {
        this.bouns = bouns;
    }
    @Override
    public void work(){
      System.out.println("管理其他人");
    }
}
package Demo3;

public class Cook extends Employee{
    public Cook() {
    }

    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }
    @Override
    public void work(){
        System.out.println("厨师正在炒菜");
    }
}


package Demo3;

public class Test {
    public static void main(String[] args) {
        //    创建对象，并赋值调用
        Manager m = new Manager("heima001","张三",14888,5000);
        System.out.println(m.getId()+","+m.getName()+","+m.getSalary()+","+m.getBouns());
        m.work();
        m.eat();
System.out.println("---------------------");

        Cook c = new Cook();
        c.setId("heima002");
        c.setName("李四");
        c.setSalary(6999);
        System.out.println(c.getId()+","+c.getName()+","+c.getSalary());
        c.work();
        c.eat();
    }


}
3.多态 
（1）多态的基本认识

如果没有多态：

代码重复累赘 

有了多态后：

package Demo1;

public class Person {
    private String name;
    private  int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public void  show(){
        System.out.println(name+","+age);
    }
}
package Demo1;

public class Student extends Person{

    @Override
    public void show(){
        System.out.println("学生的信息为："+getName()+","+getAge()+"岁。");
    }

}

package Demo1;

public class Teacher extends Person{
    @Override
    public void show(){
        System.out.println("老师的信息为："+getName()+","+getAge()+"岁。");
    }
}

package Demo1;

public class Administrator extends Person{
    @Override
    public void show(){
        System.out.println("管理员的信息为："+getName()+","+getAge()+"岁。");
    }
}

package Demo1;

public class Test {
    public static void main(String[] args) {
//        创建三个对象，并调用register方法
        Student s = new Student();
        s.setAge(18);
        s.setName("张三");

        Teacher t = new Teacher();
        t.setAge(34);
        t.setName("李四");

        Administrator a = new Administrator();
        a.setAge(48);
        a.setName("王五");

        register(s);
        register(t);
        register(a);


    }
//这个方法既可以接收老师，学生还可以接收管理人员的信息
//只能把参数写成这三个类型的父类

    public static void register(Person p){
        p.show();
    }
}

（2）多态调用成员的特点

（3）多态的优势和弊端

instanceof：表示判断，变量a是不是属于Dog类型，若不是，if语句则将转其Dog类型

AYTOY
关注
06面向对象进阶
Yang_Jin_的博客
04-01 275
面向对象进阶 JVM内存的分配 编译器将.java文件转化为.class文件 .class文件被交给类加载器（三种）----在内存中分配空间 JVM（java虚拟机）会将内存分为5块： 栈：java栈的区域比较小，空间1M，特点：（存取数据）速度非常快，在栈里执行的基本上都是快速任务，存基本数据类型和对象的引用 堆：new出来的对象都存放在堆里面，堆里面的每一个对象都会产生一个唯一的地址，内存地...
Python基础之面向对象进阶
07-20 250
Python基础之面向对象进阶一：面向对象之组合二：单例设计模式2.1 __ new__方法 一：面向对象之组合 组合即在类中封装另一个类的对象。 组合的意义：让类的对象与另一个类的对象产生关系，类与类之间产生关系。 让两个类之间产生关系：一是继承，二是组合。 class GameRole: def __init__(self, nickname, ad, hp): self.nickname = nickname self.ad = ad # 血值
Python面向对象进阶学习
09-19
### Python面向对象进阶学习知识点 #### 一、前言 在初步掌握了Python面向对象的基础概念后，进阶的学习显得尤为重要。本篇文章旨在为读者提供更深入的理解与实践指南，帮助大家更好地掌握Python面向对象编程的...
python进阶_浅谈面向对象进阶
09-21
### Python进阶之面向对象进阶 面向对象编程（Object-Oriented Programming，简称OOP）是现代软件开发中一种非常重要的编程范式。Python作为一种支持面向对象特性的语言，其面向对象编程功能强大且灵活。本文将深入...
面向对象进阶，面向对象进阶
09-10
本节我们将深入探讨面向对象的进阶概念，包括封装、继承、多态以及接口等核心原则，帮助开发者更好地理解和运用这一强大的编程范式。 1. 封装：封装是面向对象的基础，它将数据和操作数据的方法绑定在一起，形成一...
C++程序设计_面向对象进阶_C++_
09-30
**C++程序设计_面向对象进阶_C++_** C++是一种强大且广泛应用的编程语言，它由Bjarne Stroustrup在C语言的基础上发展而来，引入了面向对象的编程特性，同时也支持过程化编程。面向对象编程（Object-Oriented ...
python面向对象进阶之路
12-21
众所周知，python是门面向对象编程语言，面向对象是一个程序设计和编程思想，即一切皆为对象。 面向对象 面向对象三要素：封装，继承， 多态 封装？ 把一致的行为或者公共的部分封装成一个类或者方法。 比如把一定...
Java-网络
2301_81543552的博客
09-14 334
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 331
如果在新建Android项目时报错：Read timed out或者connect timed out。
Java Exception 异常相关总结
最新发布
持续学习和分享感兴趣的技术
09-14 136
Java Exception 异常的相关总结。
上传文件到钉盘流程详解
jspyth的博客
09-14 415
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 592
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 384
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
m0_66572126的博客
09-14 416
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
MyBatis面试
Tony_yitao的博客
09-09 814
MyBatis面试
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 588
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
Java面向对象进阶：类的继承与访问控制
"面向对象进阶的Java基础知识，包括访问控制、super与this、类的继承、方法的重写与重载等内容。" 在Java编程语言中，面向对象编程（Object-Oriented Programming, OOP）是核心特性之一，它允许我们以更符合现实...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值