java学习笔记（面向对象oop）

最新推荐文章于 2024-05-19 18:51:10 发布
最新推荐文章于 2024-05-19 18:51:10 发布
阅读量112 收藏
点赞数 4
文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zlq825/article/details/133498660
版权

面向对象编程（OOP）

初识面向对象

  • 属性+方法=类
  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，让然需要面向过程的思路去处理。
  • 面向对象本质就是：以类的方式组织代码，以对象的组织（封装）数据。
  • 从认识论角度考虑是先有对象后有类
  • 三大特性：封装，继承，多态。抽象

回顾方法的定义以及调用

定义

  • main方法
//main方法
public static void main(String[] args){}
/*
修饰符 返回值类型 方法名(...){
	//方法体
	return 返回值;
}
*/
public String sayHello(){
    return "hello world";
}
public void print(){
    return;
}
public int max(int a,int b){
    return a>b ?a:b;
}

break：跳出switch循环，结束循环。continue：结束依次循环。return：方法结束，返回类型和返回值相同。

方法名：见名知意，驼峰命名法。参数列表：（参数类型，参数名），…可变参数，数组运用可变参数。

  • 静态方法：
public static void say(){
    system.out.print("1111");
}//可直接通过方法名调用，和类一起加载。
  • 非静态方法
public void say(){
    System.out.print("1111");
}
//调用
Student student = new Student();//实例化这个类new，对象类型 对象名=对象值;
student.say();
  • 形参
public static int add(int a,int b){//int a,int b,形参
	return a+b;    
}
  • 实参
public static void main(String[] args){
    int add = Demo03.add(1,3);//1,3:实参
    System.out.println(add);
}
  • 值传递
//值传递
public class Demo04{
   public static void main(String[] args){
       int a=1;
       System.out.println(a);
       
       Demo04.change(a);
       System.out.println(a);
   }
    
    //返回值为空
    public static void change(int a){
        a=10;
    }
}

a=10，返回值为空，a的值还为1。

  • 引用传递
//引用传递：对象，本质还是值传递
public class Demo05{
    public static void main(String[] args){
        Person person = new Person();
        
        System.out.println(person.name);//null
        
        Demo05.change(person);
        
        System.out.println(person,name);//test
    }
    public static void change(Person person){
        //person是一个对象：指向的--->Person person=new Person();这是一个具体的人，可以改变属性
        person.name = "test";
    };
}


//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}
  • 基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的
  • 对象作为参数传递时，是对象在内存中的地址拷贝一份给了参数

类和对象的关系

  • 类是一种冲向的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
  • 对象是抽象概念的具体实例

创建和初始化对象

  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的使用

1595485938430

  • 一个类即使什么都不写，它也会存在一个方法
  • 构造器：
    • 和类名相同
    • 没有返回值
  • 核心作用：
    • 使用new关键字，本质是在调用构造器
    • 构造器同来初始化值
  • 在无参构造器中，无参构造器可以实例化初始值

1595486615687

  • 注意点：
    • 有参构造器：一旦定义了有参构造，无参就必须显示定义
    • Alt+Insert

内存分析

1595487183165

img

在这里插入图片描述

小结类与对象

1.类与对象

类是一个模板：抽象，对象是一个具体的实例

2.方法

定义，通用

3.对应的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈—>堆

4.属性：字段Field成员变量

默认初始化：

数字：0 0.0

char：u0000

boolean：false

引用：null

修饰符 属性类型 属性名=属性值;

5.对象的创建和使用

必须使用new关键字创建对象，构造器Person xiaoming=new Perosn();

对象的属性 xiaoming.name

对象的方法 xiaoming.sleep()

6.类

静态的属性 属性

动态的行为 方法

封装

  • 该露的露，该藏的藏
    • 我们程序设计要追求”高内聚，低耦合“。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
  • 封装（数据的隐藏）
    • 通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，称为信息隐藏。
  • 属性私有，get/set
//名字
private String name;

//学号
private int id;

//性别
private char sex;

//年龄
private int age;

public int getAge(){
    if(age>120 || age<0){
        this.age=3;
    }else{
        this.age=age;
    }
    return age;
}

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

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

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

public int getId(){
    return id;
}

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

public char getSex(){
    return sex;
}

public void setSex(char sex){
    this.sex=sex;
}
Students s1=new Students();        
s1.setAge(1200);        
System.out.println(s1.getAge());
  • 作用
    • 提高程序的安全性，保护数据
    • 隐藏代码的实现细节
    • 统一接口
    • 系统可维护性增加了

继承

  • 继承的本质是对某一批类的抽象，从而实现对世界更好的建模
  • extends的意思是“扩展”。子类是父类的扩展，使用extends来表示
  • **Java中只有单继承，**没有多继承！一个类只能继承一个父类
  • 继承是类与类之间的一种关系，此外还有依赖、组合、聚合等
  • 继承关系的两个类，一个是子类（派生类），一个是父类（基类）子类继承父类
  • 子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承
  • 在Java中，所有类，都默认直接或间接继承Object类（Ctrl+H可以查看类关系）
  • 被final修饰的类，无法继承（断子绝孙）

super&this

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个（默认调用）

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

VS this

  • 代表的对象不同：
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  • 前提
    • this：没有继承也可以使用
    • super：只能在继承条件下可以使用
  • 构造方法
    • this()：本类的构造
    • super()：父类的构造
  • super与this的区别：super代表**父类对象的引用，只能在继承条件下使用；**this调用自身对象，没有继承也可以使用
super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

在这里插入图片描述

在这里插入图片描述

方法的重写

  • 重写：需要有继承关系，子类重写父类的方法！方法名必须相同
  • 参数列表必须相同
  • 修饰符可以扩大但是不可以缩小
    • public>protected>default>private
  • 抛出的异常：范围，可以被缩小，但是不能扩大：ClassNotFoundException–>Exception(大)
  • 重写是方法的重写，与属性无关
  • 重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
  • 被**static（属于类，不属于实例），final（常量方法），private（私有）**修饰的方法不能重写
public class B{
    public static void test(){静态方法
        System.out.println("B==>test()")
    }
}
public class A extends B{//继承
    public static void test(){
        System.out.println("A==>test()")
    }
}
public class Application(){
    public static void main(String[] args){
        //方法的调用只和左边的定义的类型有关
        A a = new A();
        a.test();//打印A==>test()
        
        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test();//打印B==>test()
    }
}

修改A.Java，B.java

public class B{
    public void test(){//非静态方法
        System.out.println("B==>test()");
    }
}
public class A extends B{
    @Override //重写了B的方法
    public void test(){
        System.out.println("A==>test()");
    }
}
//父类的引用指向了子类
B b = new A();
//子类重写了父类的方法，执行子类的方法
b.test();//打印变成了A==>test()
/*
静态方法是类的方法，非静态方法是对象的方法。有static时，b调用了B类的方法，因为b是B类定义的。没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
*/

重写：子类的方法名必须和父类保持一致，方法体不同

被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写

为什么重写：

  • 父类的功能，子类不一定需要，或者不一定满足

Alt + Insert ; override;

多态

  • 即同一方法可以根据发送对象的不同而采用不同的行为方式
  • 一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
  • 多态存在条件
    • 有继承关系
    • 子类重写父类的方法
    • 父类引用指向子类对象

1595932129829

注意点

  1. 多态是方法的多态，没有属性的多态
    1. 父类和子类，有联系 类型转换溢出：ClassCastException
    2. 存在条件：继承关系，方法需要重写，父类引用指向了子类对象

instanceof和类型转换

  • instanceof引用类型比较，判断一个对象是什么类型

1595939583793

  • 类型转换
    • 父类引用指向子类的对象
    • 把子类转换为父类，向上转型，会丢失自己原来的一些方法
    • 把父类转换为子类，向下转型，强制转换，才调用子类方法
    • 方便方法的调用（转型），减少重复的代码，简洁

static

  • 静态变量可以直接用类名访问，也称类变量
  • 静态变量（或方法）对于类，所有对象（实例）共享
  • 静态变量可以直接调用，但是非静态变量不可以直接调用
private static int age;
private double score;
public void run(){	}
public static void go(){	}

public static void main(String[] args){
    Student s1 = new Student();
    System.out.println(Student.age);
    System.out.println(Student.score);
    System.out.println(s1.ahe);
    System.out.println(s1.score);
    go();
    run();
}
  • 静态区代码加载类时一起被初始化，最早执行且只执行一次（第一次new）
public class Person{
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }
    public static void main(String[] args){
        Person person = new Person();
        System.out.println("=====================")
        Person person2 = new Person();
        System.out.println("=====================")
        Person person3 = new Person();
    }
}
  • Math->随机数:
//静态导入包
import static java.lang.Math.random;
public class Application {    
    public static void main(String[] args) {        
        //第一种随机数，不用导包        
        System.out.println(Math.random()); 
        //0.7562202902634543        
        //第二种随机数，静态导入包        
        System.out.println(random()); 
        //0.5391606223844663    
    }
}

抽象类

  • abstract修饰的类就是抽象类，修饰的方法就是抽象方法
  • 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类
  • 抽象类不能使用new来创建对象，它是用来让子类继承的
  • 抽象方法只有方法的声明，没有实现，让其子类实现
  • 子类继承抽象类，必须实现抽象类的所有方法， 否则该子类也要声明为抽象类

1596091374081

1596091427354

  • 编译器给抽象类添加了一个无参构造方法。

接口

接口最能体现OOP的精髓，对 对象 的抽象

在Java编程语言中是一个抽象类型，是抽象对象的集合，对象通常以interface关键字来声明。

  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）共存
  • 接口：只有规范，无法自己实现
    • 约束和实现分离->面向接口编程

接口就是规范，定义一组规则，它的本质是契约，制定好之后大家都要遵守。

声明

[可见度] interface 接口名称 [extends 其他的接口名] {       
    // 声明变量  
    
    // 抽象方法 
}
/**
*用户接口，需要实现类
*锻炼抽象的思维
*/
public interface UserService{
    //定义的属性默认是静态常量：public static final
    int age = 10;
    
    //定义的方法是公共抽象：public abstract
    void add(String str);
    void delete(String str);
    void update(String str);
    void query(String str);
}
public interface TimeService{
    void timer();
}

特性

  • 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
  • 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字
  • 接口中的方法都是公有的。

实现

/*
抽象类用继承：extends
接口用实现：implements
类可以实现接口，需要实现所有方法！
利用接口实现伪多继承~
*/
public class UserServiceImplement implements UserService,TimeService{
    @Override
    public void add(String str){
        
    }
    
    @Override
    public void delete(String str){
        
    }
    
    @Override
    public void update(String str){
        
    }
    
    @Override
    public void query(String str){
        
    }
    
    @Override
    public void timer(){
        
    }
}

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常

在实现接口的时候，也要注意一些规则：

  • 一个类只能继承一个类，但是能实现多个接口
  • 一个接口能继承另一个接口，这和类之间的继承比较相似

继承

接口的继承使用extends关键字，子接口继承父类接口的方法

//文件名：Sports.java
public interface Sports{
    public void setHomeTeam(String name);
    public void setVisitingTeam(String name);
}

//文件名：Football.java
public interface Foorball extends Sports{
    public void homeTeamScored(int points);
    public void visitingTeamScored(int points)
    public void endOfQuarter(int quarter);
}

//文件名：Hockey.java
public interface Hockey extends Sports{
    public void homeGoalScored();
    public void visitingGoalScored();
    public void endOfPeriod(int period);
    public void overtimePeriod(int ot);
}

多继承

  • 类不允许多继承
  • 接口允许多继承
public interface Hockey extends Sports,Event

1596094615952

接口与类相似，一个接口可以有多个方法

接口与类的区别

  • 接口不能被实例化
  • 接口没有构造方法
  • 接口中所有的方法必须是抽象方法
  • 接口不能包含成员变量，除了static和final变量
  • 接口不是被类继承，而是被类实现
  • 接口支持多继承（实现类（implements） 可以实现多个接口）
  • 实现类必须要重写接口中的方法

1596094313451

JDK8之后的新特性，支持在接口中实现具体方法，但需要default修饰。default修饰方法只能在接口中使用。

内部类

内部类：在一个类的内部再定义一个类

class A{
    class B{
        
    }
}

A是B的外部类，B是A的内部类。

成员内部类

public class Outer{
    private int id;
    public void out(){
        System.out.println("外部类的方法");
    }
    
    //成员内部类
    public class Inner{
        public void inner(){
            System.out.println("内部类的方法");
        }
        
        //可以直接使用外部类的属性/方法
        public void getOuterId(){
            System.out.println("内部类调用外部类属性和方法");
            //创建成员内部类之前肯定要创建外部类对象
            //即使id不是静态变量，out不是静态方法，但创建外部类对象时已经存在。
            System.out.pirntln(id);
            out();
        }
    }
}

image-20200512155751798

匿名内部类

public class Application{
    public static void main(String[] args){
        //匿名内部类在多线程中使用，到时候再深究
        Thread thread = new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("匿名内部类实现线程的逻辑操作");
            }
        });
        //开启操作
        thread.start();
    }
}

回到顶部

异常

Java把溢出当做对象来处理，并定义了一个基类Java.lang.Throwable作为所有异常的超类。

Java语言定义了许多异常类在Java.lang标准包中，主要分为Error和Exception两大类。

img

在这里插入图片描述

在这里插入图片描述

五个关键字try、catch、finally、throw、throws

使用try和catch关键字可以捕获异常。try/catch代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码。

finally区可以不要，在IO流，资源关闭时使用。

捕获多个溢出：从小到大！

IDEA快捷键：选中健康区域代码–>Ctrl + Alt + T

public static void main(String[] args) {
        int a=1;
        int b=0;


        try{
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("Error");
        }catch(Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }
    }
    public void a(){b();}
    public void b(){a();}

抛出异常

throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型

throws是用在方法名尾部，可以声明抛出多个溢出，多个溢出之间用逗号隔开。

import java.io.*;
public class className{
    public void withdraw(double amount) throws RemoteException,InsufficientFundsException{
        //Method implementation
    }
    //Remainder of class definition
}

throw是用在方法体内，主动抛出异常

public class ThrowTest{
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        
        try{
            System.out.println(divide(a,b));
        }catch (Exception e){
            System.out.println("分母不能为0");
            //e.printStackTrace();
        }
    }
    
    public static double divide(int a,int b){
        if(b == 0){
            //主动抛出异常
            throw new ArithmeticException();
        }
        return 1.0*a/b;
    }
}

自定义异常

在这里插入图片描述

//自定义的异常类
public class MyException extends Exception{
    private int detail;
    
    public Myexception(int a){
        this.detail = a;
    }
    
    //异常的处理信息
    //tostring
    @Override
    public String toString(){
        return "Myexception{" + "detail=" + detail + "}";
    }
}
public class Appcication{
    //可能存在异常方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为：" + a);
        if(a>10){
            throw new MyException(a);//抛出
        }
        System.out.println("ok");
    }
}

public static void main(String[] args){
    try{
        test(11);
    }catch (MyException e){
        System.out.println("MyException=>" + e);
    }
}

总结

  • 处理运行是异常时，采用逻辑去合理规避，同时辅助try-catch处理
  • 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
  • 对于不确定的代码，也可以加上try-catch，处理潜在的异常
  • 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
  • 具体如何处理异常，要根据不同的业务需求和异常类型去决定
  • 尽量添加finally语句块去释放占用的资源
zlq825
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java学习笔记10之OOP阶段项目
hanq2016的博客
04-19 880
java学习笔记，持续更新，非常完整，OOP阶段项目
java学习笔记 - 7
08-08
1.类和对象 类和对象的定义 创建类和对象 2访问对象 3shoot --射击游戏第一天的策划 需要注意的内容
JAVA学习笔记：面向对象（OOP）
个人学习笔记
06-24 109
文章目录面向对象概述类和对象程序中的类与对象类的结构创建对象 面向对象概述 什么是面向对象？ 简写OOP，既Object Oriented Programming,面向对象编程。注意其与面向过程的区别。 面向过程：是具体化的，流程化的，解决一个问题，需要一步一步的分析，一步一步的实现。 例如想吃鱼香肉丝，去买食材、调料，再进行烹饪、装盘。 优点：性能比面向对象好、因为调用时需要实例化、开销大、消耗资源大。 缺点：不易维护、不宜复用、不宜扩展。 面向对象：是模型化的，你只需抽象出一个类，这是一个封闭的盒子
Java学习笔记-面向对象
Aaaabt的博客
03-31 123
Java学习笔记-面向对象 ​ Java的核心就是面向对象编程，即OOP ​ （本笔记基于狂神的Java课程及自己个人的总结） 1、面向过程&面向对象 面向过程思想（线性思维） 步骤清晰简单，第一步做什么，第二步做什么… 面向过程适合处理一些较为简单的问题 面向对象思想 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。 对于描述复杂的事
面向对象OOP学习笔记
Fzzfxx的博客
06-16 67
面向对象 OOP 封装 继承 构造器 抽象类 接口 多态 方法重写 方法重载
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 6894
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
java学习笔记（面向对象oop）（六）
u012028498的专栏
06-22 56
面向对象编程 面向对象编程（Object-Oriented Programming,OOP） 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。 抽象 三大特性 （封装，继承，多态） 静态方法可直接调用 非静态方法需要 new 需要类实例化 package com.hongyuan.oop; public class Demo02 { public static void main(String[] args) { Demo01 demo01 = new D
关于java中面向对象编程（OOP）的学习笔记
chb47100的博客
11-02 94
面向对象编程 面向对象思想 方法回顾与加深 对象的创建分析 面向对象三大特性 抽象类和接口 内部类与OOP实战 面向过程 & 面向对象 面向过程思想 步骤清晰简单 面对过程适合处理一些简单的问题 面向对象思想 物以类聚，分类的思考模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索 面向对象适合处理复杂的问题，适合处理多人协作的问题。 对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思
Java笔记整理(面向对象OOP)
“Hello World”
12-15 560
java面向对象学习笔记
Java 学习笔记（三）面向对象编程（OOP)
落心尘的博客
10-03 123
面向对象编程（OOP) **面向对象：**把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式 **类：**属性+方法; 面向对象编程本质：以类的方法组织代码，以对象的形式（封装）数据； 一、面向对象特性 封装 继承 多态 二、类与对象的关系 类是一种抽象的数据类型，它是对某一类事物整体的描述/定义，但是并不代表某一个具体的事物; 类是同一种事物的统称，是一个抽象的概念； 对象是对类的一个具体描述，是一个客观的实体； 对象是抽象概念的具体实例化；
JAVA学习笔记_Day4_OOP(面向对象)
哈哈哈哈_哈士奇的博客
05-26 168
Java编程基础——复习 java编程基础： 　 　　1.基本数据类型 　　2.变量 　　3.运算符 　　4.语句 　分支选择语句　条件循环语句 　　5.方法　方法的五要素　（递归方法） 　　6.数组 　　 　　面向过程编程：把解决问题的思路分解成若干个步骤，每个步骤用方法实现，然后按照一定的顺序调用方法 　　程序　＝　数据结构　＋　算法 　　　　　　　变量/数组　　　解决问题的思路 Java...
达内JAVA面向对象笔记
02-25
达内学习Java的面向对象笔记,内容精简.
C#ch07笔记1.jpg
09-14
java面向对象学习编程笔记核心整理
C#ch06笔记2.jpg
09-14
java面向对象学习编程笔记核心整理
C#ch06笔记1.jpg
09-14
java面向对象学习编程笔记核心整理
jar包增量更新分析
junlaiyan的专栏
05-16 285
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 1053
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring-Cloud 微服务
weixin_65127444的博客
05-15 913
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 644
本文主要提供用java实现的拼图小游戏源代码。
TwinCAT3面向对象OOP
05-13
TwinCAT 3是一款面向对象的编程工具，它支持C++和C#等面向对象编程语言。在TwinCAT 3中，可以使用类、对象、继承、多态等面向对象编程的概念来编写程序。 TwinCAT 3的面向对象编程主要体现在以下几个方面： 1. 类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值