【JavaSE】- 面向对象(高级)

已于 2023-07-10 16:37:08 修改
阅读量56 收藏
点赞数 1
文章标签： java 开发语言
于 2023-07-06 15:41:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62605243/article/details/131554504
版权
文章详细阐述了Java中类变量的定义、访问、细节及应用场景，包括静态和实例变量的区别，以及如何通过类名或对象访问它们。同时，介绍了main方法的作用、注意事项和参数使用。此外，讨论了代码块的概念，包括静态和普通代码块的执行时机和顺序，以及它们在构造器中的作用。
摘要由CSDN通过智能技术生成

面向对象（高级）

1.1🌠类变量的定义

先看这段代码

public class ChildGame {
    public static void main(String[] args) {
        Child jack = new Child("jack");
        Child tom = new Child("tom");
        Child marry = new Child("marry");

        jack.join();
        jack.count++;
        tom.join();
        tom.count++;
        marry.join();
        marry.count++;

        System.out.println("共有"+Child.count+"名小孩加入了游戏");
        System.out.println(jack.count);
        System.out.println(tom.count);
        System.out.println(marry.count);
    }
}
class Child{
    private String name;
    public static int count = 0;

    public Child(String name) {
        this.name = name;
    }
    public void join(){
        System.out.println(name+"加入了游戏...");
    }
}

run
在这里插入图片描述
解析
当一个类里的成员被static关键字所修饰时，这就意味着这个类成员会被这个Child类所有实例化的对象所共享

内存分析
在这里插入图片描述
解析
先进行类加载，再加载类变量，之后加载Child这个类的信息，然后是默认初始化，接着是显式初始化，最后是构造器初始化，初始化后，child1对象和child2对象都指向方法区里的静态域里的count变量

总结
(1)static变量是在同一个类中被所有实例化的对象所共享
(2)static变量在类加载中就已经生成了

1.2🌭访问类变量

(1).类变量是随着类的加载而加载,不创建对象也可以访问
(2).创建对象来访问

public class VisitStatic {
    public static void main(String[] args) {
        // 访问类变量
        // (1).类变量是随着类的加载而加载,不创建对象也可以访问
        System.out.println(A.name);
        //System.out.println(A.n); //err
        
        // (2).创建对象来访问
        A a = new A();
        System.out.println(a.name);
        //System.out.println(a.n); //err
    }
}

class A{
    // 类变量
    public static String name = "小明";
    // 私有类变量
    private static int n = 10;
}

run
在这里插入图片描述

1.3🍐类变量细节

(1).类变量是该类的所有对象所共享的，而实例变量是每个对象独享的
(2).static变量是叫类变量或静态变量，否则称为实例变量/普通变量/非静态变量
(3).类变量可以通过类名.成员名或对象.成员名访问，而普通变量只能通过对象.成员名访问。(前提是满足访问修饰符的访问权限)
(4).类变量是在类加载时就初始化了，在没有创建对象之前，类加载了，就可以使用类变量了
(5).类变量的生命周期是随着类的加载开始随着类消亡而消亡


public class StaticDetail {
    public static void main(String[] args) {
        B b = new B();
        //System.out.println(B.n1);
        System.out.println(B.n2);

        //静态变量是类加载的时候，就创建了,所以我们没有创建对象实例
        //也可以通过类名.类变量名来访问
        System.out.println(C.address);

    }
}

class B {
    public  int n1 = 100;
    public static int n2 = 200;
}

class C {
    public static String address = "北京";
}

在这里插入图片描述

1.4🍷类变量应用场景

使用场景
如果在方法中不涉及和对象有关的成员，则可以将方法设计成静态方法提高开发效率

System.out.println("9的开平方结果："+Math.sqrt(9));
System.out.println(MyTools.sum(10,20));

class MyTools{
    public static double sum(int n1,int n2){
        return n1+n2;
    }
}

通过上面的例子不难看出，不用创建对象就能调用方法，实在是太裤辣！！！

1.5🍼类方法细节

(1).类方法中不能使用this和super这种和对象有关的关键字
(2).普通方法中可以访问静态方法和静态变量
(3).静态方法只能访问静态方法和静态变量

public class Test {
    public static void main(String[] args) {
        D.hi();//ok
        //非静态方法，不能通过类名调用
        //D.say();, 错误，需要先创建对象，再调用
        new D().say();//可以
    }
}
class D {
    private int n1 = 100;
    private static int n2 = 200;
    
    //非静态方法,普通方法
    public void say() {
    }

    //静态方法,类方法
    public static  void hi() {
        //类方法中不允许使用和对象有关的关键字，
        //比如this和super。普通方法(成员方法)可以。
        // System.out.println(this.n1); // err
    }

    //静态方法只能访问静态成员.
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);不能使用
        hi();//OK
        //say();//错误
    }
    //非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

多说不练假把式

1.6🌽类方法练习

class Test {
    static int count = 9;
    public void count() {
        System.out.println("count=" + (count++));
    }
    public static void main(String args[]) {
        new Test().count(); 
        new Test().count();
        System.out.println(Test.count);
    }
}

run
9 、10 、 11
解析
静态变量随着类加载而加载，随着类结束而消亡

class Person {  
   private int id;
   private static int total = 0;
   public static int getTotalPerson() {
       //id++;//错误, 注销

       return total;
   }
   public Person() {//构造器
       total++;  //total = 1
       id = total;//id = 1
   }
}
class TestPerson {
   public static void main(String[] args) {
       System.out.println("Number of total is " +Person.getTotalPerson()); //0
       Person p1 = new Person();
       System.out.println( "Number of total is "+ Person.getTotalPerson()); //1
   }
}

run
0、1


class Person { 
    private int id;
    private static int total = 0;
    public static void setTotalPerson(int total){
        // this.total = total;//错误，因为在static方法中，不可以使用this 关键字
        Person.total = total;
    }
    public Person() {//构造器
        total++;
        id = total;
    }
    //编写一个方法，输出total的值
    public static void m() {
        System.out.println("total的值=" + total);
    }
}
class TestPerson {
    public static void main(String[] args) {
        Person.setTotalPerson(3);
        new Person(); 
        Person.m();
    }
}

run
4

2.1🤗详解main方法

public static void main(String[] args){}

1.main方法是jvm虚拟机调用
2.jvm虚拟机需要调用类的main方法,所以该方法的访问权限必须是public
3.jvm虚拟机在执行main方法不需要创建对象,所以是static
4.可以接收String类型数组参数，该数组中保存java命令时所传递的参数
5.java 执行程序 参数1 参数2 参数3 …

2.2🍏main方法注意事项


public class Main01 {
    private static int n1;
    private static void m1(){}
    private int n2;
    private void m2(){}
    
    public static void main(String[] args) {
        // main方法本身就是静态方法
        // (1)静态方法只能包含静态成员
        m1();
        System.out.println(n1);
        
        // (2)静态方法只能包含普通成员
        // m2();  // err
        // System.out.println(n2); // err


        // (3)如果静态方法非要访问普通成员，必须实例化一个对象
        Main01 main01 = new Main01();
        main01.m2();
        System.out.println(main01.n2);
    }
}

2.3🍇main方法中的String数组传参

在这里插入图片描述
在这里插入图片描述
注意要点击右下角的应用
在这里插入图片描述
也是成功运行！

3.1🍍代码块的定义

先看一段代码


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

        Movie movie = new Movie("你好，李焕英");
        System.out.println("===============");
        Movie movie2 = new Movie("唐探3", 100, "陈思诚");
    }
}

class Movie {
    private String name;
    private double price;
    private String director;

    //3个构造器 -》重载
    //(1) 下面的三个构造器都有相同的语句
    //(2) 这样代码看起来比较冗余
    //(3) 这时我们可以把相同的语句，放入到一个代码块中，即可
    //(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //(5) 代码块调用的顺序优先于构造器..

    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    };

    public Movie(String name) {
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
    }

    public Movie(String name, double price) {

        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {

        System.out.println("Movie(String name, double price, String director) 被调用...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

run
在这里插入图片描述
总结
如果构造器中有重复的语句，可以使用代码块，减少代码冗余

3.2🍈代码块细节

在谈代码块细节之前大家需要知道类在什么时候会被加载

(1).创建对象实例时


public class CodeBlockDetail01 {
    public static void main(String[] args) {
        BB bb = new BB();

    }
}
class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码1被执行...");//1
    }
}

在这里插入图片描述

(2).子类对象实例化时，父类也会被加载，而且，父类先被加载，子类后被加载

    
         AA aa2 = new AA();
         
class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码1被执行...");//1
    }
}

class AA extends BB {
    //静态代码块
    static {
        System.out.println("AA 的静态代码1被执行...");//2
    }
}

在这里插入图片描述

(3).使用类的静态变量时

         System.out.println(Cat.n1);


class Animal {
    //静态代码块
    static {
        System.out.println("Animal 的静态代码1被执行...");//
    }
}

class Cat extends Animal {
    public static  int n1 = 999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat 的静态代码1被执行...");//
    }
}

在这里插入图片描述
可以看到，执行顺序是父类先加载执行父类的代码块，然后是子类的静态代码块，最后是子类的静态变量

(4).static代码块，是在类加载时，执行的，而且只会执行一次.

        DD dd = new DD();
        DD dd1 = new DD();
    }
}

class DD {
    //静态代码块
    static {
        System.out.println("DD 的静态代码1被执行...");//
    }
}

在这里插入图片描述

(5).普通的代码块，在创建对象实例时，会被隐式的调用。
被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行

		DD dd = new DD();
        DD dd1 = new DD();
        System.out.println(DD.n1);//8888, 静态模块块一定会执行


class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码1被执行...");//
    }
    //普通代码块, 在new 对象时，被调用，而且是每创建一个对象，就调用一次
    //可以这样简单的，理解 普通代码块是构造器的补充
    {
        System.out.println("DD 的普通代码块...");
    }
}

在这里插入图片描述
总结
(1).只有在创建对象时，普通构造器才会调用,调用静态成员时不会被调用
(2).创建对象实例和调用静态成员时静态代码块会被执行，静态代码块只会执行1次，还要注意类的3个加载方式…

代码块在一个类中的执行顺序
（1）如果有多个静态代码块和多个静态变量初始化，就看他们定义的顺序
（2）如果有多个普通代码块和多个普通变量初始化，就看他们定义的顺序
（3）最后看构造器

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();// (1) A 静态代码块01 (2) getN1被调用...(3)A 普通代码块01(4)getN2被调用...(5)A() 构造器被调用
    }
}

class A {
    //静态属性的初始化
    private static  int n1 = getN1();

    static { //静态代码块
        System.out.println("A 静态代码块01");
    }

    public static int getN1() {
        System.out.println("getN1被调用...");
        return 100;
    }

    //无参构造器
    public A() {
        System.out.println("A() 构造器被调用");
    }

    private int n2 = getN2();//普通属性的初始化

    { //普通代码块
        System.out.println("A 普通代码块01");
    }

    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2被调用...");
        return 200;
    }
}

在这里插入图片描述

构造器中隐含着super和调用普通代码块

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();//(1)AAA的普通代码块(2)AAA() 构造器被调用(3)BBB的普通代码块(4)BBB() 构造器被调用
    }
}

class AAA { //父类Object
    {
        System.out.println("AAA的普通代码块");
    }
    public AAA() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}

class BBB extends AAA  {
    {
        System.out.println("BBB的普通代码块...");
    }
    public BBB() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}

在这里插入图片描述

  1. 父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
  2. 子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
  3. 父类普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
  4. 父类的构造方法
  5. 子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
  6. 子类的构造方法
package codeblock_03;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //(1) 进行类的加载
        //1.1 先加载 父类 A02 1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        new B02();//对象
    }
}

class A02 { //父类
    private static int n1 = getVal01();

    static {
        System.out.println("A02的一个静态代码块..");//(2)
    }

    {
        System.out.println("A02的第一个普通代码块..");//(5)
    }

    public int n3 = getVal02();//普通属性的初始化

    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }

    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02的构造器");//(7)
    }

}


class B02 extends A02 { //

    private static int n3 = getVal03();

    static {
        System.out.println("B02的一个静态代码块..");//(4)
    }

    public int n5 = getVal04();

    {
        System.out.println("B02的第一个普通代码块..");//(9)
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }

    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");//(10)

    }
}

在这里插入图片描述

1.静态代码块只能调用静态成员
2.普通代码块可以调用所有成员


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

        new C02();
    }

}


class C02 {
    private int n1 = 100;
    private static int n2 = 200;

    private void m1() {

    }

    private static void m2() {

    }

    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }

    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}

在这里插入图片描述

3.3🍒代码块练习题

public class CodeBlockExercise01 {
    public static void main(String[] args) {
        System.out.println("total = "+ Person.total); //100
        System.out.println("total = "+ Person.total); //100
    }
}
class Person {
    public static int total;//静态变量
    static {//静态代码块
        total = 100;
        System.out.println("in static block!");//(1)
    }
}

在这里插入图片描述


public class CodeBlockExercise02 {
}

class Sample
{
    Sample(String s)
    {
        System.out.println(s);
    }
    Sample()
    {
        System.out.println("Sample默认构造函数被调用");
    }
}
class Test{
    Sample sam1=new Sample("sam1成员初始化");//
    static Sample sam=new Sample("静态成员sam初始化 ");//
    static{
        System.out.println("static块执行");//
        if(sam==null)System.out.println("sam is null");
    }
    Test()//构造器
    {
        System.out.println("Test默认构造函数被调用");//
    }
    //主方法
    public static void  main(String  str[])
    {
        Test a=new Test();//无参构造器
    }

}

在这里插入图片描述

在这里插入图片描述

难吃的茄子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
面向对象程序设计：JavaSE-任务101
08-08
面向对象程序设计是Java SE（标准版）的核心特性之一，任务101主要涉及文件和流的操作，以及图像处理。在此任务中，我们将探讨如何利用Java进行文件管理、流的使用，以及图像的拆分与合并。 首先，我们来看文件管理...
javaＳＥ－－－－基础
10-20
Java是一种高级的、面向对象的编程语言，起源于1995年，由Sun Microsystems公司（现已被Oracle公司收购）推出。它以其“Write Once, Run Anywhere”（一次编写，到处运行）的理念，成为了跨平台应用开发的首选语言。...
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
03-03
- **对象与类**：Java是一种面向对象的语言，理解类和对象的概念，如何创建、实例化以及它们之间的关系至关重要。 - **封装、继承和多态**：这是面向对象的三大特性，封装确保数据安全，继承实现代码复用，多态...
5-JavaSE之面向对象编程-类与对象（上）1
08-03
面向对象编程是Java的核心特性，它使得代码更加结构化、可维护性更强。在这个主题中，我们将探讨类与对象的概念，以及与它们相关的其他关键概念。...在实践中，还需要掌握继承、多态和接口等更高级的面向对象概念。
javase-思维导图.zip
08-04
其次，面向对象编程（OOP）是Java的核心特性。这涉及类、对象、封装、继承、多态等概念。类是对象的模板，对象是类的实例；封装允许我们隐藏实现细节，提供公共接口与外界交互；继承使得一个类可以继承另一个类的...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 1660
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 1610
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 1982
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2265
linux上datax 安装以及使用
操作系统原子操作
zzt_is_me的博客
08-28 676
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 435
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 277
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1068
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
C++的内存模型
qhu1600417010的博客
08-28 465
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
优秀的开源项目
最新发布
猪猪
08-28 353
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 200
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 687
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
功能强大的开源数据中台系统 DataCap 2024.03.9 发布
qianmoQ - 关注云计算,关注大数据
08-28 141
DataCap 发布！https://datacap.devlive.org/download.html
Java面试宝典-java基础02
杜盟恩的博客
08-27 249
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Java SE面向对象高级：继承与方法覆写详解
面向对象高级是Java编程中的重要概念，特别是对于初学者来说。在JavaSE中，面向对象的核心包括类、对象、封装、继承和多态。在这个文档中，我们将深入探讨以下几个关键知识点： 1. **类的继承**：类的继承是面向...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值