章四、面向对象（3）—— 面向对象特征

已于 2024-02-23 19:06:03 修改
阅读量607 收藏 17
点赞数 16
文章标签： java 开发语言
于 2024-02-21 23:01:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/king_faner/article/details/136203013
版权

面向对象语言的三大特征 封装 继承 多态

一、封装

● 封装的概念

        封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 。

● 封装的好处

        1.只等通过特定的方法访问

        2.隐藏类的信息

        3.方便加入控制语句

        4.方便修改实现

 例1：将类中的成员私有化

public class Person {
    private String name; //设置成私有的，在其他类中无法访问无法访问
    int age;


    //设置一个特殊的公共方法，使在其他类中可以试用这个方法对类中私有的成员变量进行修改
    public void setName(String name){
        if(name.length()<6&&name.length()>2){
            this.name = name;
        }
    }

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

public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person();
        //在其他类中可以直接对类中的属性进行赋值操作，但是还没有办法控制七复制的内容
//报错： p1.name = "张三";  //private String name;
        p1.age = 10;     //int age;
        p1.setName("AAA");
        System.out.println(p1.getName());

    }
}

例2：将类中的方法私有化

Java设计模式：解决魔种问题的固定方法（算法）

单例模式：让一个类，在一个程序中只能创建一个对象

将类的构造方法私有化（private），外界不能随意调用，并向外界提供一个获取该类对象的方法

● 右键菜单栏中的Generate工具

其中的功能有Constructor（构建方法）、Getter（取得值）、Setter（设置值）、Override Methods（方法重写）。。。

● 补充变量的分类

按数据类型分：

        基本类型变量（8种）：byte、int、short、long、float、double、char、boolean

        引用数据类型：类、数组        持有的是对象的引用数据

在类中的位置不同

        成员变量：在类中定义

        局部变量：在方法中定义或者方法的参数

权限修饰不同

        成员变量：可以使用权限修饰符

        局部变量：不可以使用权限修饰符

初始化不同

        成员变量：创建对象后,由构造方法初始化

        局部变量：没有默认初始化值，必须定义，赋值。

生命周期不同

        成员变量：随着对象的创建而存在，随着对象的销毁而消失

        局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

在内存中的位置不同

        成员变量:与对象一起在堆内存中

        局部变量: 与方法一样在栈中

二、继承

● 概念

就是将同一事物中共性的属性和行为进行抽取，定义在一个类中（基类），其他类可以继承基类

        多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么，多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成继承关系

● 程序实现

先写一个动物类（Animal）：

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

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

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

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

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

    //展示名称
    public void showInfo(){
        System.out.println("名字："+name+" 年龄："+age);
    }

    public void eat(){
        System.out.println(this.name+"吃东西");
    }

}

然后写猫（Cat）和狗（Dog）：

public class Cat extends Animal{
    public void catchMouse(){
        System.out.println(getName()+"捉老鼠");
    }
}
public class Dog extends Animal{
    public void lookHouse(){
        System.out.println(getName()+"看家");
    }
}

注意：

        在写猫（Cat）和狗（Dog）的类的时候，因为猫和狗是继承于动物（Animal）的，所以要用 extends 关键词声明，格式如下：

（声明类B继承于类A）

[修饰符] class 类A {

        ...

}

[修饰符] class 类B extends 类A {

        ...

}

其中

类B，称为子类/派生类

类A，称为父类/基类

最后测试一下：

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("小黑");
        cat.setAge(6);

        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setAge(5);

        //猫和狗的名字年龄
        cat.showInfo();
        dog.showInfo();

        //行为
        //吃东西
        cat.eat();
        dog.eat();

        //不同的行为
        //捉老鼠
        cat.catchMouse();
        //看家
        dog.lookHouse();

    }
}

结果：

● 继承性的特点：

        ● 子类会继承父类所有的实例变量和实例方法

        ● 子类不能直接访问父类中私有的(private)的成员变量和方法

        ● 在Java 中，继承的关键字用的是“extends”，表示子类是对父类的扩展

        ● Java支持多层继承(继承体系)

        ● 一个父类可以同时拥有多个子类

        ● Java只支持单继承，不支持多重继承

        类 java.lang.Object,是类层次结构的根类，即所有其它类的父类。每个类都使用 Object作为超类。当一个类没有显示的继承其他类时,默认继承Object类。

● 方法的重写（OverRide）

• 方法重写

当父类的方法功能实现不能满足子类需求时,可以对方法进行重写( override)。

        子类可以对从父类中继承来的方法进行改造，我在程序执行时，子类的方法将覆盖父类的方法。们称为方法的重写也称为方法的覆盖。

注意：构造方法，静态方法不能重写，成员变量不存在重写

• 方法重写的规则

        1. 子类重写的方法必须和父类被重写的 方法名称，参数列表相同。

        2. 子类重写的方法的 返回值类型 与父类保存一致。

        3. 子类重写的方法使用的 访问权限不能小于父类被重写方法的访问权限。

                注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写

        4. 子类方法抛出的异常不能大于父类被重写方法的异常（后续讲）

• @Override 使用说明：

        @Override是java中定义的 注解标签 ，用来进行标记(进阶部分细讲)写在方法上面，表示此方法是从父类重写而来，用来检测是不是满足重写方法的要求。

        （这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。）

建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

    @Override
    public void eat(){
        System.out.println(getName()+"啃骨头");
    }
    /*
    @Override
    public void eat(String name){

    }
    当重写的方法与父类不同时，@Override会报错
     */

        同样可以调用右键工具栏中的 Generate工具 来快速重写方法；

● super 关键字

在Java类中使用super来 调用父类 中的指定操作：

        super 可用于 访问父类中定义的属性

        super 可用于 调用父类中定义的成员方法

        super 可用于 在子类构造器中调用父类的构造器

注意：

        尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

        super的追溯不仅限于直接父类，还可以是父类的父类

        super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

误区：

        不要把super误认为是父类对象，在创建子类对象时，不会创建父类对象。只会将父类中的信息加载到子类对象中存储。

● 继承中的构造方法

        ● 子类继承父类时，不会继承父类的构造方法。只能通过“super（形参列表）”的方式调用父类指定的构造方法。

        ● 规定 super（形参列表），必须声明在构造器的首行。

        ● 如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器默认调用super()，即调用父类中空参的构造器。

        ● 这么做是为了保证先对父类成员进行初始化。

开发中常见错误：

        如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则编译出错。

例：

父类（Animal类）：

public class Animal {
    //构造类型
    private String name;
    private int age;

    //构造方法
    public Animal(){
        System.out.println("Animal类的无参构造方法");
    }
    //有参构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("这个是父类的有参构造方法，其中name = "+name+",age = "+age);
    }
}

子类（Dog类）：

public class Dog extends Animal {

    //构造方法
    public Dog(){
        //如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器默认调用super()，即调用父类中空参的构造器。
        //super();
        System.out.println("Dog类的无参构造方法");
    }
    
    //有参构造方法
    public Dog(String name, int age) {
        //规定 super（形参列表），必须声明在构造器的首行。
        super(name, age);
        System.out.println("这个是子类的有参构造方法，name = "+name+",age = "+age);
    }
}

测试类：

public class TestDog {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //当调用子类构造方法是，必须先调用父类的构造方法
        //如果没写的时候会默认调用无参的构造方法

        //当调用有参的构造方法时
        Dog dog1 = new Dog("旺财",5);
    }
}

结果：

● 抽象类

● 抽象方法：

        抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法必须用 abstract关键字 进行修饰。

为什么要有抽象方法？

        在一些体系结构的顶端类中，有些功能没必要实现，因为不同子类中的实现都不同。

● 抽象类：

        ● 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

        ● 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。

        ● 用 abstract修饰 的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

● 特点：

        • 抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。（ 即不能" new 类( ) "）

        • 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否 则，该类也必须声明为抽象类。

● 一般语法：

[访问权限] abstract class 类名 {

        成员列表

}

        抽象类、抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

 例：

父类：

//当类中的对象被 abstract修饰时，类也必须用 abstract类修饰
//抽象的类不能用 new
public abstract class Animal {
    private String name;
    private int age;

//    public void eat(){
//        System.out.println("动物吃东西");
//    }

     public abstract void eat();//如果没有方法体会报错，就要用abstract修饰
}

子类：

public class Dog extends Animal{
    //重写过来的eat()方法
    @Override
    public void eat() {

    }
}

三、多态

● 多态

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{

        ……

}

class Cat extends Animal{

        ……

}

class Dog extends Animal {

        ……

}

Animal c = new Cat() //Animal 的引用指向Cat的对象

Animal d = new Dog() //Animal 的引用指向Dog的对象

● 向上转型

class Animal{

        void eat(){ }

}

class Cat extends Animal{

        void eat() {

                System.out.println("狗吃骨头");

        }

}

………

Animal x=new Cat() ;        //向上转型，Cat对象提升到Animal对象

x.eat() ;                               //在编译时期只能调用父类中定义的方法, 如果子类重写了父类方法,那么运行时调用子类重写的方法

例：

父类（Animal）：

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


    public void eat(){
        System.out.println("动物吃东西");
    }
}

子类（Dog）：

public class Dog extends Animal{

    public void eat(){
        System.out.println("狗啃骨头");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //Dog dog = new Dog();
        //多态：可以声明一个父类的对象
        Animal dog = new Dog();//Animal的引用指向Dog类的对象


        dog.eat(); //这里调用的是父类的 eat()方法;
        //但当子类对父类的方法重写后，则会调用子类的方法

}

运行结果：

● 多态性的好处

提高代码的扩展性

class Animal{

        void eat() { }

}

class Cat extends Animal{

        void eat() { }

}

class Dog extends Animal{

        void eat(){ }

}

//方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象

method(Animal animal){

        animal .eat();

}

例如写一个冰箱装东西：

一般来说：

public class IceBox {

    //装肉
    public void putDog(Meat meat){ //要装东西，肯定要引入对象
        System.out.println("把"+meat.getName()+"冰箱");
    }
    //装菜
    public void putCat(Vegetables vegetable){
        System.out.println("把"+vegetable.getName()+"冰箱");
    }
    //这种写法不利于程序扩展，每添加一种动物就要写一种方法
    }

}

        我们会创建一个冰箱类，然后给每一个要装进冰箱的对象分别写一个方法。但显然，这种方法不仅麻烦，还不利于后期维护

既然如此，我们就可以利用多态的性质：方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象

    public void putAnimal(SomeThing thing){
        System.out.println("把"+thing.getName()+"装进冰箱");
    }

这时，我们会想到，不是有一个最高级别的父类（Object）存在嘛，那我们不就可以通过Object类来将所有的自定义类全部包含进去：

    public void putObject(Object object){ //Java中所有的类都继承 Object类
        System.out.println("把东西装进冰箱");
    }

● 多态环境下的调用

        • 多态环境下对成员方法的调用

class Animal{

        void show() {

                System.out.println(“Anmial");

        }

}

class Cat extends Animal{

        void show() {

                System.out.println(“cat");

        }

}

…….

Animal x = new Cat()

x.show()         //调用的是子类中的方法

简单的说：编译看左边，运行看右边。

        • 多态环境下对静态成员方法的调用

class Animal{

        static void show() {

                System.out.println(“Animal");

        }

}

class Cat extends Animal {

        static void show() {

                System.out.println(“Cat");

        }

}

…….

Animal x = new Cat()

x.show()         //调用的是动物类中的静态成员方法。

简单的说：编译和运行都看左边。

        • 多态环境下对成员变量的调用

class Animal{

        int num = 3;

}

class Cat extends Animal {

        int num = 4;

        }

…….

Animal x = new Cat()

x.num;         //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

● 向下转型

父类引用仅能访问父类所声明的属性和方法，不能访问子类独有的属性和方法。

class Animal{

        void eat(){ }

}

class Cat extendsAnimal{

        void look() {

                System.out.println("看家");

        }

}

………

Animal x=new Cat()

x.look();                  //编译报错,Animal类型中没有look方法

Cat m=(Cat)x;        //需要向下转型,转为Cat类型

m.eat() ;

m.look();                //子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。

注：转换时需要使用instanceof 关键字判断 父类类型持有的对象是否是指定的子类类型

父类类型 instanceof 具体子类类型

是---true

不是---false

四、final 关键字

        final 用于修饰类、方法、参数 和 属性

作用：（其实就是定义一个常量）

        类：不能被定义为抽象类或是接口,不可被继承

        方法：子类里不可以重写

        参数：参数值在方法中不可被修改

        属性：定义时就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改（即常亮）

/*
    final修饰类
 */
public /* final */ class FinalDemo {
    //当一个类被final修饰，就不能被定义为抽象类或是接口、不可被继承

    /*
        fianl修饰方法
     */
    public final void print(){
        System.out.println("这时父类中被final修饰的print方法");
    }
    public void printf(){
        System.out.println("这是没被fianl修饰的方法");
    }

    //final修饰成员变量
    final int count = 5;
//    count = 10; 报错
    public void changeCount(int count){
//        this.count = count; 也报错

    }

    //

}

package day4.finaldemo;
/*
public class TestFinalDemo extends FinalDemo{
    //报错： Cannot inherit from final 'day4.finaldemo.FinalDemo'

}
*/

import day4.polymorphism.Test;

//当父类的final删掉后就可以继承了
public class TestFinalDemo extends FinalDemo{
    //但在父类中有一个被final修饰的方法

    /*直接报错：
    public final void print(){
        System.out.println("这时子类的print方法");
    }
     */

    //用final修饰方法的参数，使得变量无法被改变
    public void test(final int a){
//        a = 10;  报错，因为用final修饰的变量在传参进来后不能再改变
    }

    public static void main(String[] args) {
        TestFinalDemo f = new TestFinalDemo();
        f.test(10);
        f.test(20);
    }

    //情况1：在定义类时，值确定，直接赋值，复制后不能改变，所以建议用static修饰
    final static int x = 5;
    //情况2：在定义类时，值不明确，必须在创建对象后再构造方法对其赋值，每个对象拥有一个常量
    final int y;
    public TestFinalDemo(int y){
        this.y = y;
    }

}

五、接口

● 引入

接口是计算机领域的名词，表示一种功能的定义

        例如：USB接口 定义了USB接口的规范，让其他设备区实现

● 面向接口编程

从本质上讲，接口是一种特殊的抽象类，这种抽象类中包含抽象方法

接口不能被创建对象，只能被其他类实现、重写抽象方法

● 认识接口

接口中可以定义的的内容：

        1、默认为有值的常亮

        2、默认为抽象方法

        在JDK8即之后又添加了新的方法

        3.静态方法

        4.默认方法

● 接口的定义和使用

        • 接口的定义

新建一个文件

选中Java Class

创建 Interface 接口文件

[访问修饰符] interface 接口名称 [extends 其他的接口名1，其他的接口名2]
{
        // 声明常量 抽象方法 静态方法 默认方法
} 
/*
Interface 关键字修饰接口
在接口中可以定义的内容：
JDK8之后：常亮、抽象方法、静态方法、默认方法
JDK8之前：常量、抽象方法
 */
public interface MyInterface {

    //接口里的看似是变量，实际为常亮
    int NUM = 10; //即"public static final int NUM = 10"

    //抽象方法
    public abstract void eat();

    //静态方法：可以直接通过接口名调用
    public static void test(){

    }

    //默认方法:被子类继承后调用
    default void test1(){

    }
    
}

/*
接口还可以继承 多个 接口
 */
public interface InterfaceC extends MyInterface,InterfaceA,InterfaceB{
}

        • 接口的使用

类使用 implements关键字 实现接口。在类声明中，Implements 关键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

/*
类 实现（implements) 接口
类实现接口后，要么重写接口的所有抽象方法，要么将该类声明为抽象类
 */
public class MyClass implements MyInterface,InterfaceA,InterfaceB{
    //MyInterface接口
    @Override
    public void eat() {

    }
    //InterfaceA接口
    @Override
    public void sleep() {

    }
    //InterfaceB接口
    @Override
    public void play() {

    }
}

        • 结合继承

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{

}

● 接口的特性

        • 接口是隐式抽象的，主要用来定义功能

        • 接口中可以定义静态常量、抽象方法（、静态方法、默认方法（JDK8之后的））

        • 一个接口能继承其它多个接口

        • 接口不能实例化对象

        • 接口是要被类实现,一个接口可以被多个实现

        • 当类实现接口的时候，类要实现接口中所有的抽象方法,否则，该类必须声明为抽象的类

        • 接口与实现类之间存在多态性

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

        /*
        接口与实现类之间存在多态性
         */
        MyInterface myInterface = new MyClass();
    }


}

● 接口实例

父类（Animal）：

/*
因为要有动物的名字
而接口无法定义变量
所以要用抽象类
 */

public abstract class Animal {
    //成员
    private String name;
    private int age;

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


    //抽象方法
    public abstract /*抽象的*/ void eat();

    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;
    }

}

子类（Dog、Bird、Fish）：

/*
狗要跑，那么狗这个类（Dog）就要实现（implement）跑步（Run）这个接口
 */
public class Dog extends Animal implements Run{

    @Override
    public void eat() {

    }
    //Run接口中的功能
    @Override
    public void run() {

    }
}
/*
鸟要飞，那就要实现 Fly接口 中的功能
 */
public class Bird extends Animal implements Fly{
    @Override
    public void eat() {

    }
    //Fly 接口中的功能
    @Override
    public void fly() {

    }
}
/*
鱼想拥有游泳的功能，那么 Fish类 就要实现 Swim接口
 */
public class Fish extends Animal implements Swim{
    //父类（Animal）中继承的方法
    @Override
    public void eat() {

    }

    //Swim接口 中游泳的功能
    @Override
    public void swim() {

    }
}

接口（Run、Fly、Swim）：

/*
接口用于定义只有 纯功能 的使用，不能有属性
 */
public interface Run {
    void run();

}
/*
接口用于定义只有 纯功能 的使用，不能有属性
 */
public interface Fly {
    void fly();

}
/*
接口用于定义只有 纯功能 的使用，不能有属性
 */
public interface Swim {
    void swim();

}

测试类（Test）：

public class Test {
    public static void main(String[] args) {
        //多态

        //父类于子类之间存在多态
        Animal dog = new Dog();
        Animal bird = new Bird();
        Animal fish = new Fish();

        //接口与实现类之间也存在多态
        Run runDog = new Dog();
        Fly flyBird = new Bird();
        Swim swimFish = new Fish();
    }
}

总的来说，要是类中存在属性，变量之类的，那就要构建 类

要是类中只是为实现某些功能，那就可以创建成接口

三木几
关注
面向对象改造——50道100以内的加减法口算习题
weixin_50903128的博客
11-26 1万+
面向对象改造——50道100以内的加减法口算习题 接上篇文章，50道100以内的加减法口算习题的模块化改造基础上，对其进行面向对象的进一步改造 上文链接: link. 文章目录面向对象改造——50道100以内的加减法口算习题前言一、算式类BinaryOperation1.设计原则2.UML图3.代码实现二、 Exercise习题类与实现1.设计原则2.数据结构的选取3.UML图4.代码实现 前言 上文中所提到的模块化是在函数级，通过函数间的交互表示程序结构、分配程序功能，暂时忽略了函数的内部实现。 而
面向对象的软件工程——用例图
congee0的博客
11-26 2911
用例图 概念 用例图主要用于描述角色以及角色与用例之间的链接关系，说明的是谁要使用系统，以及他们使用系统可以做些什么。 用例图的元素 用例图的三个元素 : {参与者(Actor)，用例(Use Case)，子系统} 参与者 Actor 大多数系统具有多种类型的用户，每类用户表示为一个参与者。 用一个火柴人表示： 用例 Use Case 在不展现一个系统或子系统内部结构的情况下，对系统或子系统的某个连贯的功能单元的定义和描述。 用椭圆表示 子系统 用来展示系统的一部分功能，这部分功
面向对象设计——启发规则
FRESHET的专栏
04-12 3739
11.2 启发规则 人们使用面向对象方法学开发软件的历史虽然不长,但也积累了一些经验 。总结这些经验得出了几条启发规则,它们往往能帮助软件开发人员提高面向对象 设计的质量。 1.设计结果应该清断易懂 使设计结果清晰、易读,易懂,是提高软件可维护性和可重用性的重要措施 。显然,人们不会重用那些他们不理解的设计。保证设计结果清晰易懂的主要因素 如下*： （1）用词一致,...
面向对象——三大基本特征
随风随想
06-15 1万+
面向对象的三大基本特征：封装、继承和多态 一、封装 利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。 优点： 减少耦合：可以独立地开发、测试、优化、使用、理解和修改 减轻维护的负担：可以更容易...
五分钟带你了解面向对象的四大基本特征
qq_56904337的博客
02-27 2491
面向对象的四大基本特征 首先，我们来聊一聊什么是Java语言的特征？ 开源 跨平台的 JVM 面向对象 多线程 自动垃圾回收（这个也属于是JVM部分的） 支持网络 安全的 那么Java语言如何实现跨平台呢？ Java语言的流行离不开它的跨平台性，而该特性是由JVM实现的。 Java语言为不同的操作系统开发了不同的JDK（继承开发环境 打包工具，编译工具） JRE（运行时环境String util）JVM。 那么谈谈你对面向对象的认识和理解 原文章地址http://t.csdn.cn/T4VRa 首先，我
Java基础（四）——面向对象的四大特征
lvkemitu的博客
08-18 2941
Java基础（四）——面向对象的四大特征 一、封装： 什么是封装？ 通俗点即隐藏信息 提供使用接口给别人使用，不让别人直接操作属性或方法 封装有什么好处呢？ 1.使代码简洁 2.提交程序的可维护性 3.解耦合 提高灵活型 4.可以让你更具体的对类属性进行精细操作 二、继承： 什么是继承？ 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行
JAVA基础——面向对象程序设计的四大特性
weixin_42486795的博客
06-16 6365
1.封装性 面向对象的第一个原则是把数据和对该数据的操作都封装到一个类中，类的概念和现实世界的“事务种类”是一致的。 如电视机就是一个类，每台电视机都有尺寸、品牌，这些性能被封装成类的属性，每台电视机都可以开关电视、播放电视节目，这些行为动作被封装成类的方法。 对象是类的一个实例化结果，对象具有类所描述的所有属性及方法，是具体的。 每个对象都属于某个类，面向对象程序设计就是设计好相关的类，类中有属...
面向对象的三大特征——（概述）
热门推荐
Turniper的博客
12-09 2万+
面向对象的三大特征 一、封装： 将同一类事物的特征和功能包装在一起，只对外暴露需要调用的接口而已。想让你看到的你就看得到，不想让你看到的就见不到。对于封装也称为信息的隐藏，体现的最淋漓尽致的地方就是来定义接口了，在接口中我们没有任何功能的实现，只是定义了一系列抽象的方法声明。在Java中接口是体现封装最常用的方法 封装的好处： 1、实现专业的分工 2、减少代码的耦合 二、继承： 所谓继承是Java中面向对象最显著的一个特征，继承是从已有的类中派生出新的类，新的类可以吸收已有的属性、行为
面向对象程序设计——银行ATM机系统
亦然哥哥的博客
08-08 3855
文章目录针对于面向对象设计——做一个简单的银行ATM机系统ATM机需求分析用户类ATM机类银行类注册操作的大概流程登录操作的大概流程用户类代码ATM机类代码bank类代码（主类）总结 针对于面向对象设计——做一个简单的银行ATM机系统 ATM机需求分析 模拟用户注册，登录，修改密码，存钱，取钱 参与的事物有：用户，ATM机，银行（环境类） 用户类 账号 密码 余额 ATM机类 登录界面功能 注册 登录 登录成功后的界面功能 存钱 取钱 查询余额 转账 修改密码 退出 银行类 mai
Java面向对象知识详解——三大基本特征
秋名山码民的技术小屋
09-09 9366
相信很多程序员在最初接触Java的时候就听过，Java中一切皆对象那么什么是面向对象呢？前言先介绍什么是面向对象和面向过程，这样有助于读者更好的理解面向对象面向过程顾名思义是一种以过程为中心的编程思想，自顶向下的编程模式，试想一下c语言。我们将问题分解开，一个一个函数来实现一个一个的步骤，依次调用。也就是说在进行面向过程编程时候，可以先定义一个函数，然后使用if-else等方式执行代码，下面我们来看用面向过程实现一个简单算法——冒泡排序if(cur == n) //递归边界 {i < n;
山东大学软件学院面向对象课设——猜数字.zip
05-28
用户可以选择猜数字(0,1,2,3,4,5,6,7,8,9)或者字母(A,B,C,D,E,F,G,H,I,J)。开始游戏后，产生一个没有重复数字/字母的4位随机数，下面以数字为例讲解规则。用户每猜一个数字，显示出“完全猜中的数字个数”和“猜中...
面向对象——委托
01-20
使用方式：委托的名字 委托对象 = 关键字(new ) 委托的名字(所指向方法的名字)；  委托对象（[实参]）； 委托的分类：单播委托，多播委托 单播委托：所指向方法的返回类型是具体的数据类型（如：int，short等）; ...
python面向对象presentation——PPT（含源码）.rar
12-27
这份“python面向对象presentation——PPT（含源码）”是为学习者提供了一个深入理解面向对象编程的资源，适合学生用于presentation或自我学习。 1. **面向对象编程基础** - 类（Class）：类是创建对象的模板，...
Java面向对象项目——潜艇游戏
08-27
java面向对象项目——潜艇游戏，另外一个较为典型的实战项目，能够很好的帮助初学者更好的理解面向对象的思想以及对java基础知识的巩固。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 426
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 530
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1252
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 328
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三木几

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

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

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

打赏作者

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

抵扣说明：

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

余额充值