Java面向对象（三）

最新推荐文章于 2024-06-26 18:33:25 发布
最新推荐文章于 2024-06-26 18:33:25 发布
阅读量748 收藏 16
点赞数 31
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75691974/article/details/136222834
版权

    一、封装：

一般意义的封装：把一段重复代码抽取成一个函数，称为代码的封装（包装）
    面向对象语言的封装：将类的某些信息隐藏在类的内部（通过使用不同的访问权限修饰符），不许外部程序直接访问
而是通过该类提供的方法来实现对隐藏信息的操作和访问

    封装案例1：将成员变量私有化
    封装案例2：将成员方法私有化
java固定模式：解决某种问题的固定方式（算法）
    单例模式：让一个类在一个程序中只能创建一个对象（window_TestWindow）
            将类的构造方法私有化，外界不可以随便调用，向外界提供一个方法去构建
            在类中new一个static的自己，保证在类生成时，就生成了唯一的对象

    补充变量的分类：
    1、数据类型：基本数据类型、引用数据类型
    2、按照位置分：
            成员变量：在定义类中，可以使用权限修饰符修饰；
                    在构造方法中进行自动赋值；
                    生命周期不同：静态（随着类的加载而生成，类的销毁而销毁）
                               非静态（随着对象的创建，销毁而创建销毁）
                    存储位置：
                            静态：方法区
                            非静态：堆
            局部变量：在定义方法中，不能使用权限修饰符修饰
                    必须自己进行初始化
                    生命周期：随着方法调用而生成，方法调用结束而结束
                    存储位置：栈

例：

package com.wbc.opp.oop.day3.packAge;

public class Person {
    private String name;//私人权限
    private int age;//私人权限

    //定义公共的成员方法，可以在此类方法中加入控制语句
    // 外界通过调用方法来访问成员变量

    public Person(){

    }
    //通过构造方法
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }


    public void setName(String name){
        if(name.length()>2&&name.length()<6){
            this.name=name;
        }
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        if(age<150&&age>0){
            this.age=age;
        }
    }
    public int getAge(){
        return this.age;
    }
}


package com.wbc.opp.oop.day3.packAge;

public class TestPerson {
    public static void main(String[] args) {
        Person p1=new Person();
        /*
        String name;在其他类中可以直接对类中的属性进行赋值操作，但没法控制其赋值的内容
        p1.name="sdadsa";
         */
        p1.setName("abac");
        String p1Name= p1.getName();
        System.out.println(p1Name);
        p1.setAge(2);
        int p1Age=p1.getAge();
        System.out.println(p1Age);
    }
}

二、继承

继承就是将同一类事物中的共性进行抽取，定义在一个类中（基类）
其他类可以继承基类，就能拥有基类中的功能，实现代码的复用类
以及可以在子类中扩展属于子类自己的功能而不影响其他类

例：猫狗都是动物，所以可以抽取一个动物类，以继承功能

优点：提高了代码的重复率，减少了冗余。

子类使用extends关键字继承父类
一个类只能继承一个类，但可以多层继承（继承体系）

Object是所有类的父类，是java类体系中最顶尖的类
当一个类没有显示继承，默认继承Object

dog继承Animal，Dog称为子类，派生类；Animal成为父类

方法覆盖：可能有些功能比较笼统或者与具体有差距，需要更加细致的功能。
        所以出现了方法的覆盖
        当父类中方法的实现不能满足子类需求是，可以在子类中对父类的方法进行覆盖
        要求：子类重写的方法结构与父类方法结构一致（权限大于等于父类权限；返回值，名字，参数必须一致）
             父类的私有方法不能重写，挎包的默认权限方法不能重写
             子类抛出的异常不能大于父类的异常
@Override//注解标签。表示此方法是从父类重写来的，检查重写是不是正确
可以不用添加，只需要重写正确即可，但建议保留（编译器可以进行语法验证；增加可读性）

super关键字：当覆写后子类需要调用父类的方法，可以用super关键字调用
例如
      

@Override
      public void sleep() {
          super.sleep();//使用super调用父类方法
          System.out.println("哮天犬不需要睡觉");
      }
super不仅可以调用父类，还可以调用父类的父类
super与this相似，this表示当前的对象，super代表父类的内存空间的标识
this在用的时候需要创建本类对象，但super没有创建父类对象，只是将父类的信息存入子类

继承中的构造方法：
    在子类继承父类时不会继承构造方法，只能通过super构造
    在子类的构造方法首行调用父类的构造方法-> super(无参调无参，有参调有参);
    不写会默认无参构造（super();）

    常见错误：默认无参构造时，父类需要有无参构造方法

例：

Animal是父类

package com.wbc.opp.oop.day3.inherit;

public class Animal {
    private String breed;//品种
    private String name;
    private int age;
    private String gender;

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    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 printInfo(){
        System.out.println("姓名："+name);
        System.out.println("品种："+breed);
        System.out.println("性别："+gender);
        System.out.println("年龄"+age);
    }

    public Animal() {
    }

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

    public void sleep(){
        System.out.println(breed+":"+name+"正在睡觉");
    }
    public void eat(String food){
        System.out.println(breed+":"+name+"正在吃"+food);
    }
}

cat是子类之一  

package com.wbc.opp.oop.day3.inherit;

public class Cat extends Animal{
    public void catchMice(){
        System.out.println(getName()+"：正在抓老鼠");
    }
}

package com.wbc.opp.oop.day3.inherit;

public class TestCat {
    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.setName("Tom");
        cat.setBreed("抓老鼠的猫");
        cat.setGender("公");
        cat.setAge(6);
        cat.catchMice();
        cat.printInfo();
    }
}

dog是另一子类 

package com.wbc.opp.oop.day3.inherit;

public class Dog extends Animal {

    public void lookHouse(){
        System.out.println(getName()+"：正在看家");
    }
    @Override//注解标签。表示此方法是从父类重写来的，检查重写是不是正确
    public void sleep(){
        System.out.println("狗在睡觉");
    }
}

package com.wbc.opp.oop.day3.inherit;

public class TestDog {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("viky");
        dog.setBreed("泰迪");
        dog.setGender("母");
        dog.setAge(6);
        dog.lookHouse();
        dog.printInfo();
        dog.eat("狗粮");
    }
}

哮天犬又是dog的子类

package com.wbc.opp.oop.day3.inherit;

public class Xtd extends Dog{

    public void fly(){
        System.out.println("哮天犬可以飞");
    }

    //可以左键快速重写
    @Override
    public void sleep() {
        super.sleep();//使用super调用父类方法
        System.out.println("哮天犬不需要睡觉");
    }

}

package com.wbc.opp.oop.day3.inherit;

public class TestXtq {
    public static void main(String[] args) {
        Xtd xtd=new Xtd();
        xtd.setName("哮天犬");
    }
}

三、抽象类

抽象方法：只有方法声明，没有具体实现的方法
why要有抽象方法：在一些体系结构的顶端类中，有些功能没必要实现
              因为在不同子类中的实现都不相同，这时候就可以将方法声明为抽线方法
              public abstract void eat(); //定义为抽象方法，没有具体实现，不完整
              此时需要将类定义成抽象类
              public abstract class Animal {//将类使用abstract抽象化
              使用abstract关键字修饰的类就是抽象类。
              若一个类中有抽象方法，则其必须是抽象类。
              但抽象类中也可以有非抽象方法
抽象类：一个类中有不完整的方法，则这个类是抽象类
      特点：除了其不可构造对象外，其他功能与其他正常的类都相同，可以有变量，方法，构造器
           其子类必须重写其所有抽象方法，或者也定义为抽象类
      作用：主要在上层定义功能，让子类继承实现
      语法：public abstract class Animal {//将类使用abstract抽象化

例：

父类Animal（抽象类）——》子类 cat（抽象类）

                                    ——》另一子类 dog（非抽象）

package com.wbc.opp.oop.day3.Abstract;

public abstract class Animal {//将类使用abstract抽象化
    private String name;
    private int age;
    public abstract void eat(String food); //定义为抽象方法
    public Animal(){

    }

    public Animal(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 printINfo(){
        System.out.println(name+"\t"+age);
    }
}

 

package com.wbc.opp.oop.day3.Abstract;

public abstract class cat extends Animal {//定义为抽象类
}

package com.wbc.opp.oop.day3.Abstract;

public class Dog extends Animal{
    public Dog() {

    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(String food) {//重写实现
        System.out.println(getName()+"吃"+food);
    }
}

package com.wbc.opp.oop.day3.Abstract;

public class TestDog {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("旺财");
        dog.setAge(10);
        dog.printINfo();
        dog.eat("狗粮");
    }
}

四、练习

1.求学生平均成绩 编写出一个通用的人员类（Person），该类具有姓名（Name）、年龄（Age）、性别（gender）等。 然后对Person类的继承得到一个学生类（Student）， 该类能够存放学生的5门课的成绩(语文,数学,英语,物理,地理)，并有一个方法能求出平均成绩。 最后在main函数中对Student类的功能进行验证。

//person类
package com.wbc.opp.oop.homework.day3.gradeAverage;

public  class Person {
    private String Name;
    private int Age;
    private String gender;

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

    public Person() {

    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }


}
//student类
package com.wbc.opp.oop.homework.day3.gradeAverage;

public class Student extends Person {
    private double gradeAverage;
    private double chnAverage;
    private double mathAverage;
    private double engAverage;
    private double phyAverage;
    private double geoAverage;
    public Student() {
        super();
    }

    private Student(String name, int age, String gender) {
        super(name, age, gender);

    }

    private void setChnAverage(double chnAverage) {
        this.chnAverage = chnAverage;
    }

    private void setMathAverage(double mathAverage) {
        this.mathAverage = mathAverage;
    }

    private void setEngAverage(double engAverage) {
        this.engAverage = engAverage;
    }

    private void setPhyAverage(double phyAverage) {
        this.phyAverage = phyAverage;
    }

    private void setGeoAverage(double geoAverage) {
        this.geoAverage = geoAverage;
    }

    public void setAllAverage(double chnAverage,double mathAverage,double engAverage,double phyAverage,double geoAverage){
        setChnAverage(chnAverage);
        setMathAverage(mathAverage);
        setEngAverage(engAverage);
        setPhyAverage(phyAverage);
        setGeoAverage(geoAverage);
    }

    public void printInfo(){
        System.out.println("语文："+chnAverage);
        System.out.println("数学："+mathAverage);
        System.out.println("英语："+engAverage);
        System.out.println("物理："+phyAverage);
        System.out.println("地理："+geoAverage);
    }
    public double grade(){
        return (chnAverage+mathAverage+engAverage+phyAverage+geoAverage)/5;
    }
}
//测试类
package com.wbc.opp.oop.homework.day3.gradeAverage;

public class TestStudent {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setAllAverage(1,2,3,4,5);
        stu.printInfo();
        System.out.println("平均成绩为："+stu.grade());
    }
}

 

2.人类设计 定义一个人类，包括属性：姓名、性别、年龄、国籍；包括方法：吃饭、睡觉，工作。 （1）根据人类，派生一个学生类，增加属性：学校、学号；重写工作方法（学生的工作是学习）。 （2）根据人类，派生一个工人类，增加属性：单位、工龄；重写工作方法（工人的工作是……自己想吧）。 （3）根据学生类，派生一个学生干部类，增加属性：职务；增加方法：开会。

//Person类
package com.wbc.opp.oop.homework.day3.human;

public abstract class Person {
    private String name;
    private String gender;
    private int age;
    private String country;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }
    public void setAllInfo(){
        System.out.println(name);
        System.out.println(gender);
        System.out.println(age);
        System.out.println(country);;
    }

    public void eat(){
        System.out.println(getName()+"吃饭");
    }
    public void sleep(){
        System.out.println(getName()+"睡觉");
    }
    public abstract void work();
}
//Student类
package com.wbc.opp.oop.homework.day3.human;

public class Student extends Person{
    private String school;
    private String stuNums;

    public Student() {
    }

    public Student(String name,
                   String gender,
                   int age,
                   String country,
                   String school,
                   String stuNums) {
        super(name, gender, age, country);
        this.school = school;
        this.stuNums = stuNums;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getStuNums() {
        return stuNums;
    }

    public void setStuNums(String stuNums) {
        this.stuNums = stuNums;
    }

    public void getAllInfo(){
        System.out.println(getName());
        System.out.println(getGender());
        System.out.println(getAge());
        System.out.println(getCountry());
        System.out.println(school);
        System.out.println(stuNums);
    }
    @Override
    public void work() {
        System.out.println(getName()+"学习");
    }
}
//ITworker类
package com.wbc.opp.oop.homework.day3.human;

public class ITworker extends Person{
    private String unit;
    private int workAge;

    public ITworker() {

    }

    public ITworker(String name, String gender, int age, String country, String unit, int workAge) {
        super(name, gender, age, country);
        this.unit = unit;
        this.workAge = workAge;
    }

    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    public int getWorkAge() {
        return workAge;
    }

    public void setWorkAge(int workAge) {
        this.workAge = workAge;
    }
    public void setAllInfo(String unit,int workAge){
        setUnit(unit);
        setWorkAge(workAge);
    }


    public void getAllInfo(){
        System.out.println(getName());
        System.out.println(getGender());
        System.out.println(getAge());
        System.out.println(getCountry());
        System.out.println(unit);
        System.out.println(workAge);
    }

    @Override
    public void work() {
        System.out.println(getName()+"正在赛博板砖");
    }
}
//Stucadre学生干部类
package com.wbc.opp.oop.homework.day3.human;

public class StuCadre extends Student{
    private String post;

    public StuCadre() {
    }

    public StuCadre(String name, String gender, int age, String country, String school, String stuNums, String post) {
        super(name, gender, age, country, school, stuNums);
        this.post = post;
    }
    public void getAllInfo(){
        System.out.println(getName());
        System.out.println(getGender());
        System.out.println(getAge());
        System.out.println(getCountry());
        System.out.println(getSchool());
        System.out.println(getStuNums());
        System.out.println(post);
    }
    public void meeting(){
        System.out.println(post+getName()+"正在开会");
    }
}
//test类
package com.wbc.opp.oop.homework.day3.human;

public class Test {


    public static void main(String[] args) {
        Student stu =new Student("wang","男",20,"中国","snut","0001");
        stu.work();
        stu.eat();
        stu.sleep();
        stu.getAllInfo();


        ITworker worker =new ITworker("wang","男",20,"中国","非凡",1);
        worker.work();
        worker.getAllInfo();


        StuCadre cadre=new StuCadre("wang","男",20,"中国","snut","0001","学生会主席");
        cadre.work();
        cadre.getAllInfo();
        cadre.meeting();

    }
}

3、定义一个人类 , 包含一个country属性,speak(),eat()方法 派生一个中国人和美国人类, 两种人说话方式语言不同, 两种人吃饭方式不同

//person类
package com.wbc.opp.oop.homework.day3.personCountry;

public abstract class Person {
    private String country;

    public Person(String country) {
        this.country = country;
    }

    public Person() {
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }
    public abstract void speak();
    public abstract void eat();
}
//Chinese类
package com.wbc.opp.oop.homework.day3.personCountry;

public class Chinese extends Person{
    public Chinese(String country) {
        super(country);
    }

    @Override
    public void speak() {
        System.out.println(getCountry()+"人说中文");
    }

    @Override
    public void eat() {
        System.out.println(getCountry()+"人吃中餐");
    }
}
//American类
package com.wbc.opp.oop.homework.day3.personCountry;

public class American extends Person{
    public American(String country) {
        super(country);
    }

    @Override
    public void speak() {
        System.out.println(getCountry()+"人说鸟语");
    }

    @Override
    public void eat() {
        System.out.println(getCountry()+"人吃西餐");
    }
}
//test类
package com.wbc.opp.oop.homework.day3.personCountry;

public class Test {


    public static void main(String[] args) {
        Chinese chinese=new Chinese("中国");
        chinese.eat();
        chinese.speak();

        American american=new American("美国");
        american.eat();
        american.speak();
    }
}

4.学生信息管理系统 设计一个学生信息管理系统,有添加学生,查询学生,删除学生等功能. 要求:1.设计一个类学生类,学生属性有学号,姓名,性别(属性私有权限) 用来存储学生的信息 要求2:实现对学生信息的增删查操作 要求3:使用一个数组存储学生信息,数组上限定为30即可.

启动程序后输出一个菜单让用户选择操作:1.添加学生,2-删除学生,3.查询学生,4-退出
选择添加学生在控制台依次输入学号,姓名,性别等信息,将学生信息存储到一个学生对象中,
并将学生对象存储到数组中,数组容量定为30.
删除时,必须输入学号,如果学号对应的学生存在,从数组中删除该学生信息
点击查询时,必须输入学号,如果学号对应的学生存在,输出学生信息即可,不存在,输出学号有误

//Student类
package com.wbc.opp.oop.homework.day3.studentInformationManagementSystem;

/*
   学生类,主要作用,存储学生信息
 */
public class Student {


      private int num;
      private String name;
      private String gender;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }



    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}
//StudentManage类
package com.wbc.opp.oop.homework.day3.studentInformationManagementSystem;

import java.util.Scanner;

/*
   学生信息管理类
   在此类中,可以有添加,删除,查询学生信息等功能
 */
public class StudentManage {


        Student[] students = new Student[30];//[null,null,null]
        static int count=0;
        /*
           管理系统主方法
         */
         public void menu(){
               loop:while(true){
                     System.out.println("用户选择操作: 1.添加学生,2-删除学生,3.查询学生,4-退出");
                     Scanner s = new Scanner(System.in);
                     int item = s.nextInt();
                     switch (item){
                         case 1: this.add(); break;
                         case 2: this.delete(); break;
                         case 3: this.search(); break;
                         case 4:  break loop;
                     }
                 }
         }
    /*
  添加
*/
    public void add() {
        Student stu = new Student();
        Scanner name = new Scanner(System.in);
        System.out.println("请输入姓名");
        String names = name.next();
        stu.setName(names);
        Scanner num = new Scanner(System.in);
        System.out.println("请输入学号");
        int nums = num.nextInt();
        stu.setNum(nums);
        Scanner gender = new Scanner(System.in);
        System.out.println("请输入性别");
        String genders = gender.next();
        stu.setGender(genders);

        for (int i = 0; i < students.length; i++) {
            if (students[i] == null) {
                students[i] = stu;
                count++;
                break;
            }
        }
        System.out.println("添加成功");
    }

    /*
      删除
     */
    public void delete() {
        System.out.println("请输入学生学号");
        Scanner num = new Scanner(System.in);
        int nums = num.nextInt();
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null && students[i].getNum() == nums) {
                for (int j = i; j < students.length - 1; j++) {
                    students[j] = students[j + 1];
                }
                count--;
                System.out.println("删除成功");
                return;
            }
        }
        System.out.println("查无此人");
    }

    /*
      查询
     */
    public void search() {
        System.out.println("请输入学生学号");
        Scanner num = new Scanner(System.in);
        int nums = num.nextInt();
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null && students[i].getNum() == nums) {
                System.out.println(students[i].toString());
                return;
            }
        }
        System.out.println("查无此人");
    }



}
//RunStudentManage类
package com.wbc.opp.oop.homework.day3.studentInformationManagementSystem;

/*
   启动类
 */
public class RunStudentManage {

    public static void main(String[] args) {
         /*
          创建一个学生信息管理系统对象
          */
        StudentManage studentManager = new StudentManage();
        studentManager.menu();
 



    }
}

北京最后的深情
关注
  • 31
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java面向对象三大特征
qq_42530693的博客
10-26 5741
java中的面向对象的三大基本特征是:【封装】、【继承】、【多态】 1.封装 封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别 封装原则： • 将不需要对外提供的内容都隐藏起来 • 把属性都隐藏，提供公共方法对其访问 封装的好处： 1.提高重用性 2.不必关心具体的实现 3.具有安全性。 1.1 private 在Java中通过private来进行封装 private是一个修饰符，可以用来修饰成员（成员变量，成员方法） 被private修饰的.
Java面向对象三大特性
weixin_63736489的博客
04-15 5552
面向对象特性之封装性，继承性，多态性
Java面向对象浅谈
编程界明世隐的博客
12-06 4872
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java之面向对象（三）
weixin_44077638的博客
03-20 155
6.10类的分类 1、实体类 类中的内容基本上都是成员函数或成员变量，也存在静态成员 2、工具类 提供已经被实现的功能，并向外部供应，基本上都是静态函数 运用静态的原因： 共有 存在时间长 只需要加载一次，后续可随意使用 3、主类（测试类） 主要用于运行/测试代码，这个类中会有主函数的存在 实体类是可以存在主函数的 工具类一般不会存在主函数 6.11 静态...
java面向对象三要素封装继承和多态源码
10-28
java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素...
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
Java面向对象程序设计
02-19
包括设计步骤，代码设计注释，思路，以及源代码
Java面向对象流程图
12-08
学习玩Java面向对象，就决定把所有的相关知识点串联起来，这样不仅便于记忆，而且能够很好的复习学过的知识。
Java面向对象三大特性，即封装、继承、多态
12-23
Java面向对象三大特性思维导图 一、封装 封装的必要性：在对象的外部为对象的属性赋值，可能存在非法数据的录入，存在不安全隐患。就目前的技术而言，并没有办法对属性的赋值加以控制。所以要实现属性的封装非常重要...
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 473
Java爬虫Jsoup
日常工作记录目录
与海
06-21 480
EasyExcel实现二维码下载与展示
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 979
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错
最新发布
小5聊的博客
06-26 1100
找不到属性集方法。get只读属性用了反射设置setValue肯定报错
Day43
m0_67496588的博客
06-20 1220
JSON，Ajax
Homebrew使用
gghh2015的博客
06-21 432
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Rust高性能日志库tklog0.0.8—支持mod设置参数
donnie4w技术专栏
06-21 847
tklog是rust高性能结构化日志库，支持同步日志，异步日志，支持自定义日志的输出格式，支持按时间，按文件大小分割日志文件，支持日志文件压缩备份，支持官方日志库标准API，支持mod独立参数设置
SpringCloud微服务框架的原理及应用详解（一）
凛鼕将至的博客
06-21 1027
Spring Cloud是一个基于Spring Boot实现的服务治理工具包，在微服务架构中用于管理和协调服务。它提供了一系列框架和组件，如服务发现、配置管理、熔断器、智能路由等，用于简化分布式系统的开发。Spring Cloud通过提供一系列开箱即用的组件和工具，帮助开发者快速构建和部署微服务架构的系统。
SpringCloud Alibaba Sentinel基础入门与安装
小小默：进无止境
06-19 533
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北京最后的深情

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值