【java基础入门03】-面向对象（上）（30%视频学习）

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量174 收藏
点赞数 1
分类专栏： java基础入门（第2版） 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45830991/article/details/115049324
版权
这篇博客主要介绍了Java中的面向对象概念，包括类的定义、对象的创建与使用、访问修饰符、类的封装以及方法的重载。讲解了类与对象的关系，成员变量与局部变量的区别，并探讨了构造方法和this关键字的应用。
摘要由CSDN通过智能技术生成
  1. 面向对象概述
  2. java中的类与对象
  3. 类的封装
  4. 方法的重载和递归
  5. 构造方法
  6. this关键字
  7. static关键字（静态）

面向对象概述

在这里插入图片描述
面向过程：强调的是过程。也就是说完成功能的每一个步骤都需要自己来做
做菜：自己种菜自己做菜
面向对象：强调的是对象。由对象去帮我们完成具体的功能。
做菜：找一个厨师帮你做。

面向对象的好处：
1.将复杂的事情简单化
2.更符合人们的思想习惯
3.将程序员由执行者变成了指挥者

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

一、类的定义

在这里插入图片描述
在这里插入图片描述

public class Person {//public:权限修饰符 class:声明类的关键字	Person:类名
//一个类主要由以下两部分组成：
	//1、成员变量：这一个类的一些描述信息（属性等）
	String name;	//描述：人的姓名
	int age;	//描述：人的年龄
	
	//2、成员方法：这一个方法可以做一些事情（行为）
	/*
	 * 方法的定义：
	 * 权限修饰符 返回值类型 方法名(数据类型 参数名1,数据类型 参数名2....){
	 * 				方法体；
	 * 				return 返回值;
	 * 			}
	 * */
	
	//定义两个属于“Person”的方法，吃饭&睡觉
	//吃饭：有参数的方法的定义
	public void eat(String food) {
		System.out.println(name+ "正在吃"+ food);
	}
	
	//睡觉：无参数的 方法的 定义
	public void sleep() {
		System.out.println(name +"正在睡觉");
	}
	
}

知识点清查：
1.在面向对象的思想中，最核心的就是对象，为了在程序中创建对象，首先就需要定义一个类；
2.类中的方法叫成员方法，成员方法又分为实例方法与类方法；
3.类中的属性叫成员属性，成员属性又分为实例属性与类属性；
4.类用于描述多个对象的共同特征，它是对象的模板；
5.对象是类的具体化，一个类可以对应多个对象；
6.类是对象的抽象描述，对象则是该类事务的个体。
7.类是对某一类事物的抽象描述，而对象则是该类事物的个体。
8.对象是类的实例化。
9.类用于描述多个对象的共同特征，它是对象的模板。

二、对象的创建与使用

package com.itheima01;
/*
 * 类的使用：
 * 1.如何：创建对象；
 * 				类名 对象名=new 类名( )；
 * 
 * 2.如何：使用成员；
 * 				使用成员变量：对象名.变量名
 * 				使用成员方法：对象名.方法名
 * 
 * 3.对象的内存图解
 * 
 * 4.成员变量的默认初始化值
 * 			整数类型：0
 * 			浮点类型：0.0
 * 			字符类型：空白字符‘\u0000’
 * 			布尔类型：false
 * 			引用数据类型: null
 * 5.局部变量和 成员变量区别与注意事项
 * 
 * 6.堆内存垃圾的形成和解决
 *
 * */

public class Demo02 {
	public static void main(String[] args) {
		//创建Person对象：
		Person p =new Person();
		
		//使用成员：
		System.out.println(p.name);//运行结果为：null
		System.out.println(p.age);//运行结果为：0
		
		//为成员变量赋值
		p.name="张三";
		p.age=23;
		
		//再次输出成员变量
		System.out.println(p.name);//张三
		System.out.println(p.age);//23
		
		System.out.println("==============================");
		
		//使用成员方法
		//这里就会调用到之前在Person类中定义的两个方法
		p.eat("米饭");//张三正在吃米饭<----System.out.println(name+ "正在吃"+ food);
		p.sleep();//张三正在睡觉<----System.out.println(name +"正在睡觉");
	}
}

代码运行结果

对象的内存图解
5.局部变量和成员变量：

访问的特点：java遵守的是就近原则。“谁离的近就优先使用谁！”
成员变量和局部变量的区别：
（1）定义位置：
成员变量：定义在类中的方法外
局部变量：定义在类中的方法内部或者方法声明上（如这里的String food就是声明在方法上的局部变量）
（2）内存中的位置：
成员变量：在堆内存中
局部变量：在栈内存中
（3）生命周期的区别：
成员变量：随着对象的创建而创建，随着对象的消失而消失
局部变量：随着方法的调用而创建，随着方法的消失而消失
（4）默认初始化值的区别：
成员变量：有默认的初始化值
局部变量：没有默认的初始化值，使用局部变量之前，必须要给局部变量赋值。

知识点清查：
1.下面的代码的输出结果为？

package net.csdn;

class Person{
	void say() {
		System.out.println("hello");
	}
}

class Example01 {
	public static void main(String[] args) {
		Person p1=new Person();
		Person p2=new Person();
		p2.say();
		p1.say();
		p2=null;
		p2.say();
	}

}

选项
运行结果
2.创建对象时用new关键字；
3.阅读代码看输出结果：

package net.csdn;

public class Example02 {
	public static void main(String[] args) {
		String s1=new String("abc");
		String s2=s1.intern();
		String s3="abc";
		System.out.println(s1==s2);
		System.out.println(s2==s3);
		System.out.println(s1==s3);
	}
}

运行结果
解析：

package net.csdn;

public class Example02 {
	public static void main(String[] args) {
		String s1=new String("abc");//创建一个String类型的对象s1并赋值为abc
		//相当于：
		//String s1=new String();
		//s1="abc";
		System.out.println("intern()="+s1.intern());//String类的intern() 方法返回字符串对象的规范化表示形式。*01（故此处输出abc）
		String s2=s1.intern();//abc赋值给变量s2
		String s3="abc";
		System.out.println("s1="+s1);
		System.out.println("s2="+s2);
		System.out.println("s3="+s3);
		System.out.println(s1==s2);
		System.out.println(s2==s3);
		System.out.println(s1==s3);
		
		System.out.println("===========================================");
		
		//*01
		//Java intern() 方法
		/*
		 * intern() 方法返回字符串对象的规范化表示形式。
		 * 
		 * 它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为
		 * true。
		 * 
		 * 语法 public String intern() 参数 无
		 * 
		 * 返回值 一个字符串，内容与此字符串相同，但一定取自具有唯一字符串的池。
		 */
		//实例：
		String Str1 = new String("www.runoob.com");
        String Str2 = new String("WWW.RUNOOB.COM");

        System.out.print("规范表示:" );
        System.out.println(Str1.intern());

        System.out.print("规范表示:" );
        System.out.println(Str2.intern());
	}
}

运行结果：（此处有疑问）
在这里插入图片描述

三、访问修饰符

  • 在java中，针对类、成员方法和属性提供了四种访问级别，分别是private、default、protected、和public.
    访问控制符
    四种访问控制级别说明：
  • private（当前类访问级别）：如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。类的良好封装就是通过private关键字来实现的。
  • default（包访问级别）：如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问。
  • protected（子类访问级别）：如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。
  • public（公共访问级别）：这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制符修饰，那么这个类或者类的成员能被所有的类访问，不管访问类与被访问类是否在同一个包中。

访问权限修饰符的作用范围
知识点清查：

  1. protected（子类访问级别）：如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。
  2. 如果类的成员被（private）访问控制符来修饰，则这个成员只能被该类的其它成员访问，其它类无法直接访问。

四、类的封装

封装

封装后
2.接下来提供一个公共的访问方法，这个方法能对传入的值进行判断
Person类：
PERSON类

package com.itheima01;

/*封装
 * 			什么是封装？
 * 				封装就是将对象中实现的细节隐藏。不被外界所直接访问
 * 			封装的好处？
 * 				可以提高代码的安全性
 * */

public class Demo03 {
	public static void main(String[] args) {
		//创建对象
		Person p=new Person();
		//调用方法为成员变量赋值
		p.setName("张三");//用公共访问方法为私有的成员变量name进行赋值：name="张三"
		p.setAge(23);//用公共访问方法为私有的成员变量age进行赋值：age=23
		
		//调用方法获取值(这属于：调用有返回值类型的方法)
		String name=p.getName();//接收调用方法返回的name
		int age=p.getAge();//接收调用方法返回的age
		
		
		System.out.println("姓名是："+name+"，年龄是："+age);
	}

}

运行结果：
运行结果
知识点清查:

  1. 为了能让外界访问私有属性，需要提供一些使用public关键字修饰的公有方法；
  2. java提供了四种访问级别，由小到大依次是private>default>protected>public。
  3. private关键字用于将类中的属性私有化；

五、方法的重载

	程序需要针对每一种求和的情况都定义一个方法，
	如果每个方法的名称都不相同。
	在调用的时候就很难分清哪种情况应该调用哪个方法，
	为了解决这个问题，
	java允许在一个程序中定义多个名称相同，
	但是参数的类型或者个数不同的方法，
	这就是方法的重载。
	需要注意的是：
	方法的重载哦与返回值类型无关，
	它只是需要满足两个条件，
	一是方法名相同，
	二是参数个数或参数类型不同。

在这里插入图片描述

（一）、无“方法重载”的情况下求整数的和

package com.itheima02;

public class Demo01 {
	public static void main(String[] args) {
		//在主方法中调用下面定义的静态方法。
		int sum=getSum(10,20);//返回的sum在这里应有一个变量来接收
		System.out.println("sum="+sum);//运行结果：sum=30
		
		//在主方法中调用定义的静态方法：int getsumB
		int sum2=getSumB(10,20,30);
		System.out.println("sum2="+sum2);//运行结果：sum=60
		
	}	
	//定义一个求两个整数的和的方法
	/*
	 * 定义方法时的两个明确：
	 * 两个明确：
	 * 	明确参数列表：int num1 ，int num2
	 * 明确返回值类型：int 
	 * 	
	 * */
	
	//主方法main是一个静态的方法
	//如果要在主方法里面调用其它方法
	//那么这些方法也应该是静态方法(用static关键字修饰)
		public static int getSum(int num1,int num2) {
		int sum=num1+num2;
		return sum;
		}
		
	//需求2：定义一个求三个整数的方法
	/*两个明确：
	 * 1.明确参数列表：int num1,int num2,int  num3
	 * 2.明确返回值类型：int
	 * */
	public static int getSumB(int num1,int num2,int num3) {
		int sum=num1+num2+num3;
		return sum;
	}
}

注意：public static void main(String args[]){}.为什么必须要加上static呢？
这是因为：
static静态方法是存储在静态存储区内的，可以通过类.方法名直接进行调用，不需要进行实例化。
假设不使用static，那么main()方法在调用时必须先对其实例化，
而main()做为程序的主入口显然不可能先对其实例化，所以使用static修饰，可以更方便的直接用类.main()对其调用。
而需要像上面代码中的调用一样：
在主方法main()调用其它定义的方法，那么就需要用static关键字来修饰这个方法。

（二）、方法的重载

package com.itheima02;
/*
 * 方法的重载:
 * 什么是方法的重载？
 * 1.方法名相同
 * 2.方的参数列表不同（参数的个数不同，参数的数据类型不同）
 * 3.与返回值无关。
 * */

public class Demo001 {
	public static void main(String[] args) {
		
	}
	
	//两个明确：1.明确参数列表，2.明确返回值类型。
	//定义一个求两个整数的方法：
	public static int getSum(int num1,int num2) {
		int sum=num1+num2;
		return sum;
	}
	
	//定义一个求两个小数的方法：
	public static double getSum(double d1,double d2) {
		double sum=d1+d2;
		return sum;
	}
	//注意：若主方法需要调用定义在主方法中的方法
	//			则这些方法都需要使用static关键字来修饰
}

五、方法的递归

在这里插入图片描述

package com.itheima02;
/*
 * 方法的递归：
 * 指的就是方法本身自己调用自己
 * 注意事项：
 * 1.递归的次数不宜过多
 * 2.递归一定要有出口（一定要有一个结束的条件）
 * */
public class Demo02 {
	public static void main(String[] args) {
		//需求：5~1之间的数字之和
		/*
		 * 5+4+3+2+1
		 * 5+（4~1）
		 * 			4+（3~1）
		 * 					3+（2~1）
		 * 							2+1
		 * */
		int sum=getSum(5);
		System.out.println(sum);
	}
	
	public static int getSum(int num) {
		if(num==1) {
			return 1;
		}
		return num+getSum(num-1);
	}
}

方法递归的内存图解：
在这里插入图片描述

六、构造方法的定义

在这里插入图片描述
在这里插入图片描述

package com.itheima03;

public class Person {
	//Person是一个类：
	//一个类应该有如下属性：
	//1、成员变量
	//用标准的写法定义成员变量
	private String name;
	private int age;
	
	//给这两个私有的成员变量提供一个对应的get、set方法，才能间接的访问到成员变量；
	//2、get/set方法
	public void setName(String s) {
		name=s;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int a) {
		age=a;
	}
	
	public int getAge() {
		return age;
	}
	
	//普通的成员方法
	public void speak() {
		System.out.println("我的姓名是："+name+",我的年龄是："+age);
	}
}


package com.itheima03;

public class Demo01 {
	public static void main(String[] args) {
		//要使用一个自定义类，首先应该创建对象
		Person p=new Person();
		
		/* 为成员变量赋值 */
		p.setName("张三");
		p.setAge(23);
		p.speak();
	}
}

Person()调用的就是构造方法；

package com.itheima03;

public class Person {
	//Person是一个类：
	//一个类应该有如下属性：
	//1、成员变量
	//用标准的写法定义成员变量
	private String name;
	private int age;
	
	//无参（空参）的构造方法
	public Person() {
		System.out.println("构造方法被执行了");//在创建对象时就会访问到这个构造方法
	}
	
	//给这两个私有的成员变量提供一个对应的get、set方法，才能间接的访问到成员变量；
	//2、get/set方法
	public void setName(String s) {
		name=s;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int a) {
		age=a;
	}
	
	public int getAge() {
		return age;
	}
	
	//普通的成员方法
	public void speak() {
		System.out.println("我的姓名是："+name+",我的年龄是："+age);
	}
}


package com.itheima03;
/*
 * 构造方法的定义格式：
 * 			定义格式：
 * 							权限修饰符 方法名(){
 * 										方法体；			
 * 								}
 * 	1.方法名和类名要保持一致
 * 2.构造方法没有返回值类型，连void都不能写
 * 3.构造方法中不能写return语句
 * 
 * 
 * 
 * 构造方法的注意事项：
 * 	1.如果我们自己没有写任何的构造方法。系统会默认提供一个五参数的构造方法。
 * 供我们创建对象使用
 * 
 * */

public class Demo01 {
	public static void main(String[] args) {
		//要使用一个自定义类，首先应该创建对象
		Person p=new Person();
		
		/* 为成员变量赋值 */
		p.setName("张三");
		p.setAge(23);
		p.speak();
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

七、构造方法的重载

在这里插入图片描述

package com.itheima03;

public class Person {
	//Person是一个类：
	//一个类应该有如下属性：
	//1、成员变量
	//用标准的写法定义成员变量
	private String name;
	private int age;
	
	//无参（空参）的构造方法
	public Person() {
		System.out.println("空参构造方法被执行了");//在创建对象时就会访问到这个构造方法
	}
	
	public Person(String n,int a) {//有参数的构造方法，在创建对象时也必须有参数
		System.out.println("有参构造方法执行了");
		name =n;
		age=a;
	}
	
	//给这两个私有的成员变量提供一个对应的get、set方法，才能间接的访问到成员变量；
	//2、get/set方法
	public void setName(String s) {
		name=s;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int a) {
		age=a;
	}
	
	public int getAge() {
		return age;
	}
	
	//普通的成员方法
	public void speak() {
		System.out.println("我的姓名是："+name+",我的年龄是："+age);
	}
}


package com.itheima03;

public class Person {
	//Person是一个类：
	//一个类应该有如下属性：
	//1、成员变量
	//用标准的写法定义成员变量
	private String name;
	private int age;
	
	//无参（空参）的构造方法
	public Person() {
		System.out.println("空参构造方法被执行了");//在创建对象时就会访问到这个构造方法
	}
	
	public Person(String n,int a) {//有参数的构造方法，在创建对象时也必须有参数
		System.out.println("有参构造方法执行了");
		name =n;
		age=a;
	}
	
	//给这两个私有的成员变量提供一个对应的get、set方法，才能间接的访问到成员变量；
	//2、get/set方法
	public void setName(String s) {
		name=s;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int a) {
		age=a;
	}
	
	public int getAge() {
		return age;
	}
	
	//普通的成员方法
	public void speak() {
		System.out.println("我的姓名是："+name+",我的年龄是："+age);
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

七、this关键字

this关键字的作用：可以区分局部变量和成员变量同名的问题。

package com.itheima03;

public class Person {
	//Person是一个类：
	//一个类应该有如下属性：
	//1、成员变量
	//用标准的写法定义成员变量
	private String name;
	private int age;
	
	//无参（空参）的构造方法
	public Person() {
		System.out.println("空参构造方法被执行了");//在创建对象时就会访问到这个构造方法
	}
	
	public Person(String name,int age) {//有参数的构造方法，在创建对象时也必须有参数
		System.out.println("有参构造方法执行了");
		this.name =name;//等号左边的是成员变量
		this.age=age;//等号左边的是成员变量
	}
	
	//给这两个私有的成员变量提供一个对应的get、set方法，才能间接的访问到成员变量；
	//2、get/set方法
	public void setName(String name) {
		this.name=name;//等号左边的是成员变量
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int a) {
		this.age=age;//等号左边的是成员变量
	}
	
	public int getAge() {
		return age;
	}
	
	//普通的成员方法
	public void speak() {
		System.out.println("我的姓名是："+name+",我的年龄是："+age);
	}
}


package com.itheima03;
/*
 * 构造方法的定义格式：
 * 			定义格式：
 * 							权限修饰符 方法名(){
 * 										方法体；			
 * 								}
 * 	1.方法名和类名要保持一致
 * 2.构造方法没有返回值类型，连void都不能写
 * 3.构造方法中不能写return语句
 * 
 * 
 * 
 * 构造方法的注意事项：
 * 	1.如果我们自己没有写任何的构造方法。系统会默认提供一个无参数的构造方法。
 * 供我们创建对象使用
 * 2.如果我们自己写了一个构造方法，那么系统就不再提供空参的构造方法了
 * 
 * */

//this关键字的作用：可以区分局部变量和成员变量同名的问题。

public class Demo01 {
	public static void main(String[] args) {
		//要使用一个自定义类，首先应该创建对象
		//Person p=new Person();
		
		Person p=new Person("李四", 24);
		
		/* 为成员变量赋值 */
//		p.setName("张三");
//		p.setAge(23);
		p.speak();
	}
}

2.this 关键字代表的是当前对象的引用。谁来调用我，我就代表谁
在这里插入图片描述

IT日知录
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA基础知识点-入门必备
f5465245的博客
10-14 4025
本文主要是我之前复习Java基础原理过程中写的Java基础知识点总结。Java的知识点其实非常多，并且有些知识点比较难以理解，有时候我们自以为理解了某些内容，其实可能只是停留在表面上，没有理解其底层实现原理。 纸上得来终觉浅，绝知此事要躬行。笔者之前对每部分的内容对做了比较深入的学习以及代码实现，基本上比较全面地讲述了每一个Java基础知识点，当然可能有些遗漏和错误，欢迎读者指正。 Java基础知识点总结 每部分内容会重点写一些常见知识点，方便复习和记忆，但并不是全部内容。 面向对象三大...
2020老杜最新版Java零基础进阶视频教程-面向对象课件
12-10
【Java面向对象基础】 在Java编程中，面向对象是核心概念之一。面向对象编程（OOP）基于类和对象的概念，允许我们通过封装、继承和多态性来组织和管理代码。以下是一些关于Java面向对象的基础知识： 1. **final...
Java---面向过程与面向对象的区别
rbx508780的博客
09-03 1275
面向过程与面向对象的区别
Java入门-学习黑马程序员Java基础视频教程（到P92）
孟孟单单的博客
06-07 2560
Java基础学习
Java-黑马Java学习作业-day08面向对象
Kox_233的博客
01-19 2387
Java面向对象基础
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
java面向对象最全入门笔记(通俗易懂，适合初学者)
javaboy_yl
11-14 1万+
一、为什么使用面向对象 前言: 面向对象的三大特征 封装 (Encapsulation) 继承 (Inheritance) 多态 (Polymorphism) 编程思想： 面向过程：做某件事情都需要自己亲历亲为，按照步骤去完成 面向对象：做某件事情不需要自己亲历亲为，只需指定特定的对象去完成即可。 1.现实世界就是由对象组成的，如下图，万物皆对象(不是单指女朋友也不是单指男朋友哈~) 2.面...
《Java面向对象程序设计》学习笔记
weixin_45940369的博客
07-31 8077
备考某学校的 817程序设计Java 专业课，在学习耿祥义老师的《Java面向对象程序设计（第3版）-微课视频版》。 发一些自己的学习笔记到专栏（一篇文章对应书上一章），可能不会及时更新，见谅。 笔记可能有错误，看看就得，现在懒得浓缩精炼了，以后再说吧🧐
史上最强 Java 学习路线图！
热门推荐
沉默王二
04-24 27万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
java面向对象编程基础
张晨光老师的播客
03-20 2057
java面向对象编程基础 前言：什么是java 是咖啡飘香的清晨 是斯坦福校园意浓情深 是James的思想睿智 是剁手党双十一挥舞的利刃 是大数据云计算驰骋的平台 是春运时节那期盼回家的眼神 是ATM上吐出的钞票 是Android手机游走的灵魂 啊！java我的神 课程内容： Java的基础知识 Java流程控制语句 Java常用包和类 数组操作 面向对象的概念 异常处理 文件访问 数据集合操作 JDB
B站---【狂神说Java】JavaWeb入门到实战---笔记
bell_love的博客
04-23 18万+
JavaWebJava Web 1、基本概念web开发： ·web，网页的意思，www.baidu.com· 静态web 。html,sss 。提供给所有人看的数据始终不会发生变化！ 动态web 。淘宝，几乎是所有的网站； 。提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！ 。技术栈：Servlet/ISP，ASP，PHP ...
01 对象的基础概念及操作学习视频.rar_入门视频学习-01
09-23
通过观看“01 对象的基础概念及操作.avi”视频，初学者能够逐步理解并掌握这些基础概念，为进一步学习更复杂的面向对象编程技术打下坚实基础。同时，实践是提高编程技能的关键，建议配合实际编程练习，以加深理解和...
Java开发实战从入门到精通视频教程下载第5章 面向对象基础.zip
04-23
在本Java开发实战从入门到精通的视频教程中，第5章主要讲解了面向对象的基础概念，这是Java编程的核心部分。面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它以“对象”为中心，通过封装、...
动力节点_Java基础视频教程59_对象向下转型
11-18
动力节点的Java课程适合绝对零基础的观看，教程中讲解了Java开发环境搭建、Java的基础语法、Java的面向对象。每一个知识点都讲解的非常细腻，由浅入深。适合非计算机专业，想转行做Java开发的朋友，或者想让Java基础...
动力节点_Java基础视频教程224_线程-死锁
12-14
动力节点的Java课程适合绝对零基础的观看，教程中讲解了Java开发环境搭建、Java的基础语法、Java的面向对象。每一个知识点都讲解的非常细腻，由浅入深。适合非计算机专业，想转行做Java开发的朋友，或者想让Java基础...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 514
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 277
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1339
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 504
java枚举工具类
Java基础入门：面向对象编程基石
1. **面向对象概念**：面向对象编程(OOP)是Java语言的基础，它借鉴了人类自然的思维方式，通过将问题抽象为对象，强调类（对象的模板）和对象（类的具体实例）的角色。类定义了对象的属性和行为，封装性则是核心概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值