java基础学习day07（面向对象、static关键词、this关键词、super关键词）

最新推荐文章于 2024-10-27 16:50:16 发布
最新推荐文章于 2024-10-27 16:50:16 发布
阅读量154 收藏
点赞数
分类专栏： 我的java基础学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sosothing/article/details/102559807
版权

java基础学习day07（面向对象、static关键词、this关键词、super关键词）

第一章 面向对象

1.1 什么是面向对象？

1.1.1 面向对象和面向过程的区别

1.面向对象：就拿人开车来说，在人开车这个实例中，人和车就是两个对象，人负责开车，车负责被开，在这里我们只看车子能不能开动，只要具备车有开的的功能，然后人有会开车的功能，车子就能开动，这里不用去管车子如何开动，人如何去开车的。

面相对象是解决问题的一种方式，它针对一些简单的问题有一些大材小用，但是它对一些复杂的问题可以变得很轻松，面向对象是从宏观上把控事务的整体走向。

2.面向过程：还是拿人开车来说，在人开车这个实例中，涉及到很多个过程，比如说人如何去开车啊，设计到发动车子的过程，放手刹啊，挂档啊，车又是如何发动的。

面向过程是解决问题的另一种方法，他针对一些简单的问题可以很轻松的解决，但是一些复杂的问题就会很繁琐，面向过程是微观上解决问题的方法。

3.区别联系：面对对象和面对过程不是相互独立的而是相互依存的，当你通过面向对象去解决一个问题的时候，在你创建对象的时候，还是面向过程去执行解决的。在编码过程中而言，存在一个需求，先从宏观上整体看待需求，再从微观上去实际编码解决问题。

1.1.2 对象
1、什么是对象？

在java中万事万物都是对象。显示在生活中的所有的东西都是一个个的对象。每个对象都有他自己的功能，我们通过这一个个的对象可以来完成我们需要完成的相对应的需求，它减少了使用者的使用复杂度，提高了被使用者的安全度。

2、对象如何产生？

在咱们目前学习的过程中，咱们只是见过类和方法。创建对象其实是在创建类的过程中通过创建一个另外的类的对象，通过调用另一个类中的变量和方法来完成自己的需求，从而使得你遇见相同的问题不用多次编写代码来解决，直接通过该对象去调用发法变量去完成你要的需求的这么一个过程，所以类和对象必定会存在关系。

3.类和对象的关系

在java中：类是class修饰的一个类，它可以产生很多个对象，而对象则是基于类的一个实例化的表现形式。

类的产生是依赖于对象的，类是将对象中具有相同特征或者行为抽取出来归为一类，而对象的产生也是依赖于类的，如果没有类的话是无法产生该类的对象的，类是对于对象的抽像，对象是类的具象化的表现形式。

1.2 如何编写类和对象

1.2.1 如何编写类？

看如下代码：

public class FoundClass {
	//写出该类所具有的外在的表现形式（即成员变量）
	String name = "张三";
	int num = 8;
	char ch = 'A';
	//编写出该类所具有的内在功能即java中的方法
	public void write(){
		System.out.println("好好编写代码");
	}
	public void read(){
		System.out.println("读好别人编写的代码");
	}
}

tips：现在我们在去编写代码的时候，要习惯将变量写成成员变量；我们现在再去写方法的时候先不要去加static，后续过程主要去讲这个static关键字的时候我们在去看为什么。

分析代码：1.该代码中，成员变量表示为该类所具有的一些外在表现形式，以后都通过这样的方式去定义；

​ 2.该代码中，方法表示为该类所具备的内在功能，即该类能干什么，它能完成什么；

​ 3.不管是成员变量还是方法统一不用static来修饰。

1.2.2 如何编写对象？

在java中是通过new关键词来产生一个类的对象的。

看如下代码：

public class FoundObject {
	public static void main(String[] args) {
		//创建一个FoundClass对象
		FoundClass object = new FoundClass();
		//通过变量名.变量或变量名.方法来调用类的变量和方法
		String name1 = object.name;
		System.out.println(name1);
		object.write();
	}
}

注意事项：1.创建对象一定是通过new关键词来创建的；

​ 2.创建对象的基本写法：类名 变量名=new 类名();

new关键词的作用

我们基本数据类型的赋值很简单，直接赋值就好了，可是对于引用数据类型来说，我们给一个引用数据类型的变量赋值时都是要通过new关键词来赋值的，可以说new这个关键词是极其重要的。

new关键词有三个作用：

  • 看到new关键词，那么电脑会立即在堆内存中开辟空间存储类中的成员变量和方法；
  • 看到new关键词，就会给成员变量赋给它的初始值；
  • new关键词一出现，栈内存中存储的局部变量会指向引用堆内存中存储的成员变量或者是方法，将堆内存中存放的方法或者成员变量的地址值赋值给栈内存中的局部变量。

1.3 构造器

在java中 ，构造器就是用来产生对象的特殊方法，将这种特殊的方法称为构造器。

1.3.1如何声明构造器？

看如下代码：

public class FoundConstructor {
	int num = 8;
	String name = "李四";
	//创建一个该类构造器
	public FoundConstructor(){
		
	}
	public void eat(){
		System.out.println("该吃饭了");
	}
}

tip:1.构造器是一个特殊的方法，在声明是，方法名一定要和类名一致，首字母一定要大写；

​ 2.构造器在声明的时候返回值不需要写，即不用写void也不用写返回值类型；

​ 3.在构造器中的最后一行不需要return值。

1.3.2 构造器的注意事项
1.默认的构造器

在java中，如果类中没有一个构造器的生命，那么java会自动给他填充一个空参数的构造器。

2.带参数的构造器

看如下代码：

public class FoundConstructor01 {
	int num ;
	String name;
	int weight;
	public FoundConstructor01(){
		
	}
	public FoundConstructor01(int num1){
		num = num1;
	}
	public void write(){
		System.out.println("好好写代码");
	}
}

tips：

  • 在我们声明了一个带有参数的构造器后，如果我们将默认存在的无参的构造器写出来了，那么它会存在，如果我们没有声明这个默认的构造器，那么它就不会存在了；
  • 构造器也能重载。
3.创建对象调用有参构造器

看如下代码：

public class FoundConstructor01 {
	int num ;
	String name;
	int weight;
	public FoundConstructor01(){
		
	}
	public FoundConstructor01(int num1){
		num = num1;
	}
	public FoundConstructor01(int num2,String name1,int weight1){
		num = num2;
		name = name1;
		weight = weight1;
	}
	public void write(){
		System.out.println("好好写代码");
	}
}
public class FoundConstructorText {
	public static void main(String[] args) {
		FoundConstructor01 f = new FoundConstructor01();
		System.out.println(f.num);//输出结果是0;
		FoundConstructor01 d = new FoundConstructor01(6);
		System.out.println(d.num);//输出结果是6;
		FoundConstructor01 g = new FoundConstructor01(8,"张三",130);
		System.out.println(g.num+","+g.name+","+g.weight);
		//输出结果是8，张三，130；
	}
}

qtips：创建对象的方式就和方法与方法之间的调用类似，主要看的就是参数是否能够对上，创建对象时()内的实际 参数与构造器中的形式参数匹配到了即执行。

1.3.3 this关键词

this关键词一共有两种用法，为：this.和this()。

1.this.

this.代表的是当前对象的，也就是说谁在调用那么这个谁就是当前对象。

可以省略

this.大部分时候可以省略的；

看如下代码：

public class UseThis {
	String name;
	int num;
	int height;
	public UseThis(){
		this.write();
	}
	public UseThis(String yname){
		name = yname;
		System.out.println(this.name);
		
	}
	public void write(){
		System.out.println("好好写代码");
	}
}
public class UseThisText {
	public static void main(String[] args) {
		UseThis a = new UseThis();
		//输出好好写代码；
		UseThis a1 = new UseThis("张三");
		//输出张三；
	}
}

如上述代码中this.就可以省略掉不写。

不可省略

当出现了两个或多个同名变量的时候这个this.是不可以省略的，此时this.是用来区分同名变量的

看如下代码：

public class UseThis01{
	String name;
	int num;
	int height;
	public UseThis01(){
		this.write();
	}
	public UseThis01(String name){
		this.name = name;
		this.write();
	}
	public void write(){
		System.out.println(this.name+"好好写代码");
	}
}
public class UseThis01Text {
	public static void main(String[] args) {
		UseThis01 b = new UseThis01();
		//输出结果是null好好写代码；
		UseThis01 b1 = new UseThis01("张三");
		//输出结果是张三好好写代码；
	}
}

上述情况下this.不可以省略。

通常情况下我们只要记住要区分同名变量是this.是不可以省略的那么其他情况下一般都是可以省略就行了。

2.this()

this()是用来实现构造器之间的相互调用的。

看如下代码：

public class UseThis02 {
	String name;
	int num;
	int height;
	public UseThis02(){
		this("张三");
	}
	public UseThis02(String name){
		this.name = name;
		this.read();
	}
	public void read(){
		System.out.println(this.name+"好好读别人的代码");
	}
}
public class UseThis02Text {
	public static void main(String[] args) {
		UseThis02 c = new UseThis02();
		//输出结果是张三好好都别人的代码；
	}
}

注意事项：

  • this()是用来实现构造器之间的相互调用的；
  • 其他不同的方法中是不可以使用this()的，它只能在构造器中使用；
  • this()在构造器之间进行调用的时候，必须保证this()在构造器的第一行语句。

1.4 static关键词

static的意思是静态的共享的。

1.4.1 如何使用static关键词？
1.在static中使用非static修饰的

方法一：看如下代码：

public class UseStatic {
	static int num = 78;
	public static void main(String[] args) {
		System.out.println(num);
		//输出结果为78
	}
}

在static修饰的上述方法中访问未被static修饰的num变量时，在num的类型变量名前面加上static，这样可以实现访问。但是这种方法我们不推荐使用。

方法二：看如下代码：

public class UseStatic01 {
	int num = 78;
	public static void main(String[] args) {
		//创建一个对象，通过对象.num去访问这个变量
		UseStatic01 num1 = new UseStatic01();
		System.out.println(num1.num);
		//输出结果是78；
	}
}

创建当前类的对象，通过对象.方法或者变量访问非静态内容。

2.在非static中使用static修饰的

看如下代码：

public class UseStatic02 {
	static int num = 78;
	public static void main(String[] args) {
		UseStatic02 t = new UseStatic02();
		t.method();
	}
	public void method(){
		System.out.println(num*2);
		//输出结果是156；
	}
}
  • 在一个类中非静态内容访问静态内容直接通过变量名或者是方法名称就可以访问了。

再看如下代码：

public class UseStatic02 {
	static int num = 78;
	public static void main(String[] args) {
		UseStatic02 t = new UseStatic02();
		t.method();
	}
	public void method(){
		fun();	
	}
	public static void fun(){
		System.out.println(num*3);
	}
}
public class UseStatic03 {
	public static void main(String[] args) {
		UseStatic02.fun();
        //输出结果是234;
        System.out.println(UseStatic02.num);
		//输出结果是78；
	}
}

注意事项：

  • 在其他类中访问static修饰的内容时可以直接通过类名.变量名或者类名.方法名()来访问；
  • 静态内容再其他类中访问的时候可以直接通过类名来访问；也可以通过创建类的对象来访问，但是我们不推荐这种方法。
3.static的注意事项
  • static修饰的内容是属于类的，类被加载，静态内容就被加载到内存中了；
  • 而非static修饰的内容是属于对象的，只有创建了对象，它才能被调用；
  • 类信息是先于对象存在的，创建对象时类一定被加载到了内存中，但是创建了类，对象不一定加载在内存中。

1.5 继承

继承通俗理解为子承父业，它描述的是类和类之间的关系，编写类的时候，我们发现类和类之间是可以存在父子关 系的。通过 extends 来描述这种继承关系。 子类 extends 父类。

1.5.1 继承是如何表现的？

看如下代码：

public class Father {
	int weight;
	String name;
	int age;
	public Father(){
		System.out.println("父亲的无参构造器");
	}
	public Father(int weight){
		this.weight = weight;
		System.out.println("父亲的有参构造器");
	}
	public void scold(){
		System.out.println("父亲责骂儿子");
	}
}
public class Son extends Father {
	int id;
	public Son(){
		System.out.println("儿子类的无参构造器");
	}
	public Son(int id){
		this.id = id;
		System.out.println("儿子类的有参构造器");
	}
	public void play(int id){
		this.id = id;
		System.out.println("天天就知道玩");
	}
}
public class SonText {
	public static void main(String[] args) {
		Son d = new Son();
		d.weight = 130;
		d.name = "张三";
		d.age = 18;
		int id = 20140004; 
		
	}
}

程序分析：

  • 虽然Son这个类它不存在weight、age、name和scold属性，但是Father类中是存在的，也就是说我们通过extends将Father类的这些属性给了Son类。
  • 在java中一旦发生继承关系之后，子类就会拥有父类中的属性以及方法。子类无需自己再去声明。

注意事项：

  • 子类继承父类我们可以提高程序的复用性，A类继承B类，A类继承C类，这样下去会导致对于A类而言它的内部的功能是及其强大，或者是说它拥有了更多的资源和能力；
  • 在java中只支持单继承。导致复用性虽然有，但是不是特别高。针对这个问题，Java采用的策略称之为单继承、多实现；
  • 在java中一个类只有一次继承机会，如果不能完全确定最好不要用。
1.5.2 super关键词

super关键词一共有两种用法：分别为super.和super()。

1.super.的用法

super.表示当前对象的父类的对象的。

可省略

看如下代码：

public class Father {
	int weight;
	String name;
	int age;
	public Father(){
	}
	public Father(int weight){
		this.weight = weight;
		System.out.println("父亲的有参构造器");
	}
	public void scold(){
		System.out.println("父亲责骂儿子");
	}
}
public class Son extends Father {
	int id;
	public Son(){
		System.out.println(super.weight+","+super.age+","+super.name);
        super.scold();
        //输出结果是0，0，null  父亲责骂儿子；	
	}
	public Son(int id){
		this.id = id;
		System.out.println("儿子类的有参构造器");
	}
	public void play(int id){
		this.id = id;
		System.out.println("天天就知道玩");
	}
}
public class SonText {
	public static void main(String[] args) {
		Son d = new Son();
	}
}

如上述代码所示，这里的super.是可以省略的。

不可省略

看如下代码:

public class Father {
	int weight = 180;
	String name;
	int age;
	public Father(){
	}
	public Father(int weight){
		this.weight = weight;
		System.out.println("父亲的有参构造器");
	}
	public void scold(){
		System.out.println("父亲责骂儿子");
	}
}
public class Son extends Father {
	int id;
	int weight = 130;
	public Son(){
		System.out.println(super.weight+","+super.age+","+super.name);
		System.out.println(weight);
        //输出结果是180，0，null  130；
	}
	public Son(int id){
		this.id = id;
		System.out.println("儿子类的有参构造器");
	}
	public void play(int id){
		this.id = id;
		System.out.println("天天就知道玩");
	}
}
public class SonText {
	public static void main(String[] args) {
		Son d = new Son();
	}
}
  • 当父类和子类出现了同名的变量、同名方法时，为了能够区别父类和子类的同名变量或者是同名方法，此时super一定不能省略。如果省略了，默认情况下省略的是this.。子类中访问到的一定是子类自己的变量或者是方法。
2.super()的用法

看如下代码：

public class Father {
	int weight = 180;
	String name;
	int age;
	public Father(){
		System.out.println("父亲的无参构造器");
	}
	public Father(int weight){
		this.weight = weight;
		System.out.println("父亲的有参构造器");
	}
	public void scold(){
		System.out.println("父亲责骂儿子");
	}
}
public class Son extends Father {
	int id;
	int weight = 130;
	public Son(){
		System.out.println("儿子类的无参构造器");
	}
	public Son(int id){
		this.id = id;
		System.out.println("儿子类的有参构造器");
	}
	public void play(int id){
		this.id = id;
		System.out.println("天天就知道玩");
	}
}
public class SonText {
	public static void main(String[] args) {
		Son d = new Son();
	}
}

上述代码的输出结果是：父类的无参构造器 儿子类的无参构造器

注意事项：

  • 创建子类对象时之所以父类构造器被先执行原因是由于在子类构造器的第一行存在一个 super();
  • super(）指向的是父类的无参构造器(任何一类中都系统默认添加一个无参构造器)，被调用之后会在内存中创建一个父类对象；
  • 子类不能平白无故的创建，必须要保证父类存在，子类才能被创建出来。
  • super()就是用来调用父类的构造器的。
3.super()调用时机

看如下代码：

public class Person {
	String name;    
	public Person() {       
		System.out.println("person 无参构造器");    
	}   
	public Person(String name) {        
		System.out.println("person 带参构造器");   
	} 
}
public class Student extends Person {
	 int id;//学号   
	 public Student() {        
		 this(12);        
		 System.out.println("student 空can构造器");    
	 }    
	 public Student(int id) {        
		 super("123");        
		 this.id = id;        
		 System.out.println("student 有can构造器");    
	 } 
}
public class Text {
	public static void main(String[] args) {        
		Student stu = new Student();   
	} 
}

上述代码的输出结果是：person 带参构造器 student 有can构造器 student 空can构造器

注意事项：

  • 对于所有的子类而言。在子类的构造器的第一行都存在super();
  • this()和super()不能共存。当构造器中存在super，就不能显式编写this()；如果构造器中存在 this()，那么构造器中的默认super()空构造器就不存在了；
  • 父类的构造器只会被调用一次。
sosothing
关注
专栏目录
java入门学习基础.zip
08-04
"day09【继承、super、this、抽象类】.pdf"讨论了面向对象的继承特性，super关键字用于访问父类的成员，this关键字引用当前对象。抽象类不能实例化，但可以作为其他类的基类。 "day10【接口、多态】.pdf"最后介绍了...
面向对象中的修饰关键词
weixin_34417814的博客
08-18 136
final:用来修饰类和方法，修饰类的时候表示这个类是终极类，不能被其他类继承，修饰方法的时候，表示这个方法是终极方法，不能被子类重写。 static:用来修饰属性和方法，修饰属性的时候表示这个属性是静态属性，静态属性在类的外部只能用类名::$属性名这种方式访问，在类的内部还可以用self::$属性名访问。static修饰方法表示这个方法是静态方法，静态方法里不能访问非静态属性(非静态方法里可以...
Javaw基础课程笔记.zip
03-10
day06、Java 面向对象_类和对象_private关键字_this关键字。 day07、Java API概述_Scanner 概述和使用_Random使用_ArrayList集合用法。 day08：Java 字符串的基本操作_静态static关键字 day09：Java 类的继承_...
java编程教程doc
06-07
7. **类与对象**：Java 是一种面向对象的语言，支持封装、继承和多态等概念。类定义了对象的属性和行为。 ```java class Person { String name; int age; public void introduce() { System.out.println(...
java7hashmap源码-java:Java
06-04
day08_高级类特性1：多态特性、4中访问权限修饰符、this与super区别、==与equals方法区别、instanceof操作符 day09_高级类特性1：toString(方法)、包装类、static关键字 day10_高级类特性2：初始化块、抽象类、...
junit5使用suite功能
fanfangyu的博客
10-23 222
2.调用类需要的代码。
Java中的序列化和反序列化？
程序猿老白~的博客
10-23 452
Java中的序列化和反序列化？
java_方法递归调用
HHppGo的博客
10-27 253
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Spring框架注解开发
2401_85217463的博客
10-23 905
名称：@Component @Controller @Service @Repository类型：类注解位置：类定义上方作用：设置该类为spring管理的bean。
算法的学习笔记—左旋转字符串(牛客JZ58)
最新发布
业精于勤，荒于嬉
10-27 606
在这道题目中，使用三步翻转法避免了直接拼接带来的额外开销，使得操作更加高效简洁。无论是面试还是实际开发中，这种方法都非常实用。这个题目很好地锻炼了对字符串操作和数组翻转的理解，三步翻转法的思路在其他字符串旋转、数组循环移位等问题中也能得到广泛应用。希望这篇文章能帮助大家掌握并熟练应用这种方法。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
在 32 位的机器上对 long 型变量进行加减操作存在并发隐患
10-23 215
如果在多线程环境中，当一条指令执行完但另一条指令还没开始执行时，线程发生了切换，另一个线程可能就会读取到一个不完整的64位值（即“混合体”值），这就是所谓的“撕裂读”（torn read）。同样，如果在多线程环境中同时有多个线程对long型变量进行修改，由于这个操作不是原子的，一个线程的操作可能会被另一个线程的操作所覆盖或混合，导致最终的值不是任何一个线程设置的值，这就是所谓的“撕裂写”（torn write）。通过这些方法，可以确保即使在32位机器上，对long型变量的操作也是线程安全的。
Spring Boot植物健康系统：智能农业的春天
2401_85342379的博客
10-24 690
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。网站设计的关键问题是外观和技术的平衡。
如何使用Java设计一个RDB格式的Redis
hikktn的博客
10-23 453
RDB（Redis Database Backup）是一种快照持久化格式，主要用于将Redis内存中的数据保存到磁盘。文件头：标识RDB文件的格式和版本。数据库信息：存储的键值对信息。过期时间：每个键的过期时间（可选）。文件结束标识：标识RDB文件的结束。通过上述设计和实现，展示了如何从零开始设计一个简单的RDB格式的Redis持久化机制。虽然这个实现简化了很多细节，但为理解RDB格式的基本原理提供了一个良好的起点。
Java | Leetcode Java题解之第502题IPO
m0_57195758的博客
10-23 417
Java | Leetcode Java题解之第502题IPO
如何减小 Maven 项目生成的 JAR 包体积 提升运维效率
code_nn的博客
10-23 559
使用Maven打包，项目jar包体积减小 1. 排除不必要的依赖 2. 依赖jar包独立于应用jar
行为设计模式 -命令模式- JAVA
智的博客
10-24 1533
在软件系统中，行为请求者与行为实现者通常呈现一种紧耦合。但在某些场合，比如要对行为进行记录、撤销/重做、事务等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将行为请求者与行为实现者解耦？将一组行为抽象为对象实现二者之间的松耦合。这就是命令模式（Command Pattern）。某个行为有多个对象执行，并且我们需要对这个行为进行一些监控等处理。那么我们就需要将这种行为抽象出来，这种就叫做命令模式。在命令模式中有如下角色：任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
架构演进史
s8305057的博客
10-23 1010
单体架构是指将所有功能模块打包在一个独立的应用程序中。早期的计算机应用程序大多采用这种架构，所有的代码、数据和资源都集中在一个地方。服务导向架构（SOA）是一种将应用程序分解为一组相互独立的服务的架构模式。每个服务负责特定的业务功能，并通过标准化的接口进行通信。微服务架构是SOA的一种实现，它将服务进一步细化，每个服务通常围绕特定的业务功能构建，且通常是轻量级的。无服务器架构（Serverless）是一种新兴的架构模式，开发者不需要管理服务器，而是将代码上传到云服务提供商，后者负责运行环境的维护和自动扩展。
探索Spring Boot：构建高性能论坛网站
2401_85761003的博客
10-23 331
1系统概述 1.1 研究背景 随着计算机技术的发展以及计算机网络的逐渐普及，互联网成为人们查找信息的重要场所，二十一世纪是信息的时代，所以信息的管理显得特别重要。因此，使用计算机来管理论坛网站的相关信息成为必然。开发合适的论坛网站，可以方便管理人员对论坛网站的管理，提高信息管理工作效率及查询效率，有利于更好的为人们服务。 1.2研究目的 随着互联网技术的快速发展，网络时代的到来，网络信息也将会改变当今社会。各行各业在日常企业经营管理等方面也在慢慢的向规范化和网络化趋势汇合。论坛网站的信息化程度体现在将互联网
面向对象编程基础：Java OOP概念解析
"day01-JAVAOOP.md - 面向对象编程入门教程" 在本教程中，我们将深入探讨面向对象编程的基础知识，特别针对Java语言。面向对象编程（Object-Oriented Programming，简称OOP）是现代软件开发中的核心概念，尤其在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值