Java第六天

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量301 收藏
点赞数
分类专栏： 学习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaban_/article/details/123121656
版权
本文详细介绍了Java中的类与对象的概念及其区别和联系，包括类作为对象模板的角色和对象作为类实例的特性。此外，讲解了属性（成员变量）的定义、默认值以及内存分配机制，强调了栈、堆和方法区的作用。接着，讨论了成员方法的定义、调用流程和重载，以及方法的递归调用。还涵盖了构造方法在对象初始化中的重要性，以及this关键字的使用。最后，文章提到了作用域规则，特别是局部变量和全局变量（属性）的差异。
摘要由CSDN通过智能技术生成

Java第六天

类与对象

类与对象的区别和联系

public class Object01{
	public static void main(String[] args) {
		
		// String cat1Name = "小白";
		// int cat1Age = 3;
		// String cat1Color = "白色";

		// String cat2Name = "小花";
		// int cat2Age = 100;
		// String cat2Color = "花色";

		//实例化一只猫[创建一只猫对象]
		//1.new Cat() 创建一只猫
		//2.Cat cat1 = new Cat();把创建的猫赋给cat1
		//3.cat1 就是一个对象
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "白色";
		//创建第二只猫，并赋给cat2
		//cat2 也是一个对象
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age = 100;
		cat2.color = "花色";

		System.out.println("第一只猫的信息："+cat1.name+cat1.age+cat1.color);
		System.out.println("第二只猫的信息："+cat2.name+cat2.age+cat2.color);
	}
}

class Cat{

	String name;
	int age;
	String color;
}
  1. 类时抽象的，概念的，代表一类事物，比如人类，猫类…即它是一个数据类型
  2. 对象是具体的，实际的，代表一个具体事物，即实例
  3. 类是对象的模板，对象是类的一个个体，对应一个实例

属性/成员变量

基本介绍

  1. 从概念或叫法上看：成员变量=属性=field(字段)
  2. 属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型(对象，数组)
注意事项和细节说明(PropertiesDetail.java)
  1. 属性的定义语法同变量，示例：访问修饰符 属性类型 属性名；
    访问修饰符：控制属性的访问范围
    有四种访问修饰符 public，proctected，默认，private
  2. 属性的定义类型可以为任意类型，包含基本类型和引用类型
  3. 属性如果不赋值，有默认值，规则和数组一致

类和对象的内存分配机制

Java内存的结构分析

  1. 栈：一般存放基本数据类型(局部变量)

  2. 堆：存放对象(Cat cat，数组等)

  3. 方法区：常量池(常量，比如字符串)，类加载信息
    在这里插入图片描述

Java创建对象的流程简单分析

Person p = new Person();
p.name = "jack";
p.age = 10;
  1. 先加载Person类信息(属性和方法信息，只会加载一次)
  2. 在堆中分配空间，进行默认初始化
  3. 把地址赋给p，p就指向对象
  4. 进行指定初始化，如代码中的后俩行

成员方法

基本介绍
在某些情况下，我们需要定义成员方法(简称方法)。比如：人类，除了有一些属性(年龄，姓名)外，我们人类还有一些行为，比如说话、跑步…通过学习，还可以坐算术题

public class Method01{
	public static void main(String[] args) {
		
		Person p1 = new Person();
		p1.speak();//调用speak方法  		我是一个好人
		p1.cal01();//调用cal01方法		500500
		p1.cal02(9);//调用cal02方法		45
		p1.cal02(19);//调用cal02方法		190

		//调用getSum方法
		//把方法getSum返回的值赋给变量returnRes
		int returnRes = p1.getSum(10,20);
		System.out.println(returnRes);//30
	}
}

class Person{

	String name;
	int age;
	//方法
	//添加speak方法，输出”我是一个好人“
	//1.public：表示方法是公开
	//2.void：表示方法没有返回值
	//3.speak()：speak是方法名，()形参列表
	//4.{}：方法体，可以写我们要执行的代码
	public void speak(){
		System.out.println("我是一个好人");
	}

	//添加cal01方法，可以技术从1加到1000的结果
	public void cal01(){
		int res = 0;
		for(int i = 1; i <= 1000; i++){
			res += i;
		}
		System.out.println(res);
	}

	//添加cal02方法，该方法可以接收一个数n，计算从1加到n的结果
	//1.(int n)形参列表，表示当前有一个形参n，可以接收用户输入
	public void cal02(int n){
		int res = 0;
		for(int i = 1; i <= n; i++){
			res += i;
		}
		System.out.println(res);
	}

	//添加getSum方法，可以计算俩个数的和
	//1.public 表示方法是公开的
	//2.int：表示方法执行后，返回一个int值
	//3.getSum方法名
	//4.(int num1, int num2)形参列表，2个形参，可以接收用户输入的俩个数
	//5.return res；表示把res的值返回
	public int getSum(int num1, int num2){
		int res = num1 + num2;
		return res;
	}
}
方法调用小结
  1. 当程序执行到方法时，就回开辟一个独立的空间(栈空间)
  2. 当方法执行完毕，或者执行到return语句时，就会返回
  3. 返回到调用方法的地方
  4. 返回后继续向下执行代码
成员方法的定义

访问修饰符 返回数据类型 方法名 (参数列表){//方法主体
​ 语句;
​ return 返回值;
}

  1. 参数列表：表示成员方法输入
  2. 返回数据类型：表示成员方法输出，void表示没有返回值
  3. 方法主体：表示为了实现某一功能代码块
  4. return语句表是必须的
注意事项和使用细节

访问修饰符(作用是控制方法使用的范围)
如果不写 则 默认访问

返回数据类型

  1. 一个方法最多有一个返回值
  2. 返回类型可以为任意类型，包含基本类型和引用类型
  3. 如果方法要求有返回数据类型，则方法主体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或者兼容
  4. 如果方法是void，则方法主体中可以没有return语句，或者只写return；
public class MethodDetail{
	public static void main(String[] args) {
		
		AA a = new AA();

		int[] res = a.getSumAndSub(10,15);

		System.out.println("和 = "+res[0]);
		System.out.println("差 = "+res[1]);
	}
}
//1、2
class AA{

	public int[] getSumAndSub(int n1, int n2){

		int[] resArr = new int[2];
		resArr[0] = n1 + n2;
		resArr[1] = n1 - n2;
		return resArr;
	}
}

//3
public double f1(){

	double d1 = 1.1*3;
	int n = 100;
	return n;//int -> double  是可以的
}
形参列表
  1. 一个方法可以有0个参数，也可以有很多个参数，中间用逗号隔开
  2. 参数类型可以为任意数据类型
  3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
  4. 方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，实参和形参的类型要一致或者兼容，个数、顺序必须一致
方法调用细节说明
  1. 同一类中的方法调用：直接调用即可。比如：print(参数);
  2. 跨类中的方法： A类调用B类方法：需要通过对象名调用
public class MethodDetail02{
	public static void main(String[] args) {
		A a = new A();
		a.sayOk();

		a.m1();
	}
}

class A{

	public void print(int n){
		System.out.println("print()方法被调用 n = " + n);
	}

	public void sayOk(){
		print(10);
		System.out.println("继续执行sayOk()...");
	}

	public void m1(){
		B b = new B();
		b.hi();
	}
}

class B{
	public void hi(){
		System.out.println("B类中的hi()被执行");
	}
}
方法递归调用

首先先通过俩个小案例来理解递归调用机制

案例一：

public class Recursion01{
	public static void main(String[] args) {
		T t1 = new T();
		t1.test(4);
	}
}

class T{
	public void test(int n ){
		if(n > 2){
			test(n - 1);
		}
		System.out.println("n = " + n);
	}
}

在这里插入图片描述

在这里插入图片描述

案例二：

public class Recursion01{
	public static void main(String[] args) {
		T t1 = new T();
		t1.factorial(5);//120
	}
}

class T{
	public int factorial(int n){
        if(n == 1){
            return 1;
        }else{
            return factorial(n - 1) * n;
        }
    }
}

分析截图

递归重要规则
  1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
  2. 方法的局部变量是独立的，不会相互影响
  3. 如果方法中使用的是引用类型变量，就会共享该引用类型的数据
  4. 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError
  5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕
方法重载

基本介绍
java中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致
比如：System.out.println(); out是PrintStream类型
好处就是减轻了起名和记名的麻烦

public class OverLoad01{
	public static void main(String[] args) {
		
		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1,2));//calculate(int n1, int n2)被调用  3
		System.out.println(mc.calculate(1,2.0));//calculate(int n1, double n2)被调用  3.0
		System.out.println(mc.calculate(1.0,2));//calculate(double n1, int n2)被调用  3.0
		System.out.println(mc.calculate(1,1,1));//calculate(int n1, int n2, int n3)被调用  3
	}
}

class MyCalculator{

	//下面的四个calculate方法构成了重载
	public int calculate(int n1, int n2){
		System.out.println("calculate(int n1, int n2)被调用");
		return n1 + n2;
	}
	public double calculate(int n1, double n2){
		System.out.println("calculate(int n1, double n2)被调用");
		return n1 + n2;
	}
	public double calculate(double n1, int n2){
		System.out.println("calculate(double n1, int n2)被调用");
		return n1 + n2;
	}
	public int calculate(int n1, int n2, int n3){
		System.out.println("calculate(int n1, int n2, int n3)被调用");
		return n1 + n2 + n3;
	}
}
注意事项和使用细节
  1. 方法名必须相同
  2. 形参猎豹必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
  3. 返回类型无要求

可变参数

基本概念
java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法

基本语法
访问修饰符 返回类型 方法名(数据类型… 形参名){

}

public class VarParameter01{
	public static void main(String[] args) {
		
		method m = new method();
		int sum = m.sum(5,6,7,8,9);
		System.out.println(sum);//35
	}
}

class method{
	public int sum(int n1, int n2){
		return n1 + n2;
	}
	public int sum(int n1, int n2, int n3){
		return n1 + n2 + n3;
	}
	public int sum(int n1, int n2, int n3, int n4){
		return n1 + n2 + n3 + n4;
	}

	//上面三个方法名称相同，功能相同，参数个数不同 >> 使用可变参数优化

	//1.int... 表示接受的是可变参数，类型是int，既可接受多个int(0-多)
	//2.使用可变参数时，可以当做数组来使用 即nums 可以当做数组
	public int sum(int... nums){
		System.out.println("接收的参数个数= " + nums.length);
		int res = 0;
		for (int i = 0; i < nums.length; i++) {
			res += nums[i];
		}
		return res;
	}
}
注意事项和使用细节
  1. 可变参数的实参可以为0个
  2. 可变参数的实参可以为数组
  3. 可变参数的本质就是数组
  4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
  5. 一个形参列表中只能出现一个可变参数
public class VarParameterDetail{
	public static void main(String[] args) {
		int[] arr = {1,2,3};
		T t1 = new T();
		t1.f1(arr);//2.
	}
}

class T{
	public void f1(int... nums){
		System.out.println("长度 = " + nums.length);
	}

	//4.
	public void f2(String str, double... nums){

	}
}

作用域

  1. 在java编程中，主要变量就是属性(成员变量)和局部变量
  2. 局部变量一般是指在成员方法中定义的变量
  3. java中作用域的分类
    全局变量：也就是属性，作用域为整个类体
    局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中
  4. 全局变量可以不赋值，直接使用，因为有默认值，局部变量必须复制后，才能使用，因为没有默认值
public class VarScope{
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.hi();
		cat.cry();
		cat.eat();
	}
}

class Cat{

	//属性在定义时，可以直接赋值，也可以不赋值
	int age = 10;

	double weight;//默认值是0.0

	public void hi(){
		//局部变量必须赋值后才能使用
		int num;
		//System.out.println("num = " + num);//错误		
		String address = "猫";
		System.out.println("address = " + address);
		System.out.println("weight = " + weight);
	}
	{
		int num = 100;
	}
	public void cry(){
		int n = 10;
		String name = "jack";
		System.out.println("在cry中使用属性 age = " + age);
	}

	public void eat(){
		
		System.out.println("在eat中使用属性 age = " + age);
		//System.out.println("在eat中使用属性 name = " + name);//错误
		//System.out.println("在eat中使用属性 num = " + num);//错误
	}
}
注意事项和使用细节
  1. 属性和局部变量可以重名，访问时遵循就近原则
  2. 在同一个作用域中，比如在同一个成员方法中，俩个局部变量，不能重名
  3. 属性生命周期较长，伴随对象的创建而创建，伴随对象的死亡而死亡。
    局部变量生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而死亡。即在一次方法调用过程中
  4. 作用域范围不同
    全局变量/属性：可以被本类使用，或其他类使用(通过对象调用)
    局部变量：只能在本类中对应的方法使用
  5. 修饰符不同
    全局变量/属性：可以加修饰符
    局部变量不可以加修饰符
public class VarScopeDetail{
	public static void main(String[] args) {
		Person person = new Person();
		person.say();
		person.hi();

		T t = new T();
		t.test();
		t.test2(person);
	}
}

class T{
	//属性前面可以加修饰符
	public int age = 20;

	public void test(){
		Person p1 = new Person();
		System.out.println(p1.name);//jack
	}

	public void test2(Person p){
		System.out.println(p.name);//jack
	}
}
class Person{

	String name = "jack";

	public void say(){
		String name = "king";
		System.out.println("say() name = " + name);//king
	}

	public void hi(){
		String address = "北京";
		//String address = "上海";//错误
		address = "上海";
		System.out.println("address = " + address);//上海
	}
}

构造方法/构造器

基本介绍
构造方法又叫构造器，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化

基本语法
[修饰符] 方法名(形参列表){
​ 方法体;
}

说明
  1. 构造器的修饰符可以默认
  2. 构造器没有返回值
  3. 方法名和类名字必须一样
  4. 参数列表和成员方法一样的规则
  5. 构造器的调用，由系统完成
public class Constructor01{
	public static void main(String[] args) {
	
		Person p1 = new Person("smith",80);
		
		System.out.println("p1的信息如下");
		System.out.println("p1对象name = " + p1.name);//smith
		System.out.println("p1的age = " + p1.age);//80

	}
}

class Person{
	String name;
	int age;
	public Person(String pName, int pAge){
		System.out.println("构造器被调用 完成对象的初始化");
		name = pName;
		age = pAge;
	}
}
注意事项和使用细节
  1. 一个类可以定义多个不同的构造器，即构造器重载
  2. 构造器是完成对象的初始化，并不是创建对象
  3. 如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Person(){},使用javap指令反编译试试
  4. 一旦定义了自己的构造器，默认的构造器就被覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下
public class ConstructorDetail{
	public static void main(String[] args) {
		
		Person p1 = new Person("king",40);
		Person p2 = new Person("tom");
	}
}

class Person{
	String name;
	int age;//默认0
	public Person(String pName, int pAge){
		name = pName;
		age = pAge;
	}

	public Person(String pName){
		name = pName;
		System.out.println(age);//0
	}

	Doge doge = new Doge();//使用的默认的无参构造器
	Doge doge1 = new Doge("jack");//使用有参数的构造器
}

class Doge{
	/*
		默认构造器
		Doge(){
	
		}
	*/
	public Doge(String dName){

	}
	Doge(){//显式的定义一下无参构造器

	}
}

this关键字

java虚拟机会给每个对象分配this，代表当前对象

public class This{
	public static void main(String[] args) {
		
		Dog dog1 = new Dog("大黄",8);
		dog1.info();//大黄  8  当前对象的hashCode是：366712642
		Dog dog2 = new Dog("小黑",5);
		dog2.info();//小黑  5  当前对象的hashCode是：1829164700

	}
}

class Dog{
	public String name;
	public int age;
	public Dog(String name,int in_age){
		this.name = name;
		this.age = in_age;
	}

	public void info(){
		
		System.out.println(this.name + "\t" + this.age + "\t"
		 + "当前对象的hashCode是：" + this.hashCode());

	}
}

简单来说，哪个对象调用，this就代表哪个对象

this的注意事项和使用细节

  1. this关键字可以用来访问本类的属性、方法、构造器
  2. this用于区分当前类的属性和局部变量
  3. 访问成员的语法：this.方法名(参数列表);
  4. 访问构造器语法：this(参数列表)；注意只能在构造器中使用
  5. this不能再类定义的外部使用，只能在类定义的方法中使用
public class ThisDetail{
	public static void main(String[] args) {
		
		T t1 = new T();
		t1.f2();
		T t2 = new T();
	}
}

class T{

	//访问构造器语法：this(参数列表); 必须放置第一条语句
	public T(){
		//从这里去访问T(String name, int age)
		this("jack",100);
		
		System.out.println("T()构造器");

	}

	public T(String name, int age){

		System.out.println("T(String name, int age)构造器");
	}

	public void f1(){
		System.out.println("f1()方法被调用");
	}

	public void f2(){
		System.out.println("f2()方法被调用");
		//调用本类的f1
		//第一种方式
		f1();
		//第二种方式
		this.f1();
	}
}
xiaban_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中speak方法的意思,谈谈Java的面向对象
weixin_33608494的博客
03-14 1577
类的拷贝和构造C++是默认具有拷贝语义的，对于没有拷贝运算符和拷贝构造函数的类，可以直接进行二进制拷贝，但是Java并不天生支持深拷贝，它的拷贝只是拷贝在堆上的地址，不同的变量引用的是堆上的同一个对象，那最初的对象是怎么被构建出来的呢？Java对象的创建过程关于对象的创建过程一般是从new指令(我说的是JVM的层面)开始的(具体请看图1)，JVM首先对符号引用进行解析，如果找不到对应的符号引用，那...
[JAVA]方法
lumanA1380A的博客
05-08 343
JAVA方法
调用speak方法
weixin_51143067的博客
10-17 3995
当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量 当对象zhubajie调用方法speak之后，就将自己的头(head变量)，改写成：“歪着头”
【Java基础】——方法的重载与重写
LXY_YXL_JAY的博客
03-20 380
方法重载（OverLoad） 基本介绍 java 中允许同一个类中，多个同名方法的存在，但要求形参列表 不一致,返回类型无要求 好处： 1、减轻了起名的麻烦 2、减轻了记名的麻烦 入门案例： 案例：类：MyCalculator 方法：calculate calculate(int n1, int n2) //两个整数的和 calculate(int n1, double n2) //一个整数，一个 double 的和 calculate(double n2, int n1)//一个 dou
java--方法
卿本佳人的博客
01-13 1113
变量： 成员变量（全局变量，属性）与局部变量：局部与全局变量 https://blog.csdn.net/xue208212674/article/details/84971570?spm=1001.2014.3001.5501 方法的参数传递方式： 基本数据类型：参数传递是值的传递。 引用数据类型：参数传递是引用传递，传地址。 public class fangfa { static Map map = new HashMap(); static String str= new String("123
Java2实用教程第6版答案
lhy052820的博客
05-23 1799
java实习生第一天到公司
一将终成
12-15 1万+
1，首先你应该了解公司的实习生政策，以及签署三方协议的事情。工资：公司只会给实习生月薪2-8k之间。福利：饭补，车补，加班状况等。其他的就没了。实习生就是苟活，各位，不要以为咋了。 2，当你入职时，公司会让你携带，身份证复印件，学生证，银行卡复印件，三方协议（三方协议一般公司会压住，等你即将毕业才给你签，怕你跑路）。 3，第一天你该做什么工作呢？？ （1）：见见同事，见见经理，熟悉熟悉人，可以加一...
Java 的下载安装教程
热门推荐
暗诺星刻的博客
12-21 24万+
Java 17 的下载安装教程 说明： 本文介绍的是 Windows 下安装 Java 的方法。对于 Linux 下 Java 的安装，可见笔者的另一篇博客： 在 Linux 操作系统中安装 Java：https://blog.csdn.net/wangpaiblog/article/details/120093325 笔者的安装环境： JDK 17 Windows 10 教育版 安装 Java 就是安装 JDK。Java 有三大分支，这里选择的是 Java SE。关于
java 一年中的第几天_java中计算指定日期是一年的第几天的方法
weixin_42528902的博客
02-12 1435
Java输入日期计算是这年的第几天：思路通过年份区分出是闰年还是平年，平年 2 月 28 天，闰年 2 月 29 天；1、3、5、7、8、10、12 月份 31 天其余月份均为 30 天；然后将每个月的天数相加即可，注意如果输入的是 12 月份，则是从 11 月份往前累加到1月份，1月份加的是输入的天数；实现代码：import java.util.Scanner;/*** Created by x...
学习java第六天练习代码Day6.rar
02-10
"学习java第六天练习代码Day6.rar"这个压缩包正是这样一个学习阶段的体现，它包含了你在Java学习旅程中的第六天所涉及的关键概念和实践练习。以下是这些练习代码中涵盖的一些重要知识点： 1. **嵌套循环**：在Java...
java培训第十三天笔记.pdf
11-30
"Java培训第十三天笔记" Java培训第十三天笔记是Java语言的学习笔记，涵盖了Java语言的基本概念、语法和常见应用场景。在本节笔记中，我们将学习Java语言的基本数据类型、变量、运算符、控制结构、函数和数组等内容...
Java学习第二天笔记
11-25
Java学习第二天笔记 本笔记主要讲解Java的概述、环境搭建、语言特点、执行机制、设计理念、开发工具包、运行环境、虚拟机等知识点。 一、Java概述 Java是一种面向对象的程序设计语言，由Sun Microsystems于1995年...
21天学通java第六版，全本！
03-30
《21天学通Java》是一本非常受欢迎的Java初学者教程，第六版更是结合了最新的Java技术进行了全面更新。本书旨在帮助读者在21天的学习周期内掌握Java编程的基础知识，逐步进阶到能够独立编写程序的程度。下面将详细...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 515
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 764
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 146
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 516
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
集合（1）
supercool7的博客
08-12 806
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
21天速成Java 6：双语教程
"《21天学通Java6》是一本专为快速掌握Java 6语言而设计的全英文教学指南。该书由Laura Lemay、Rogers Cadenhead合著，由Sams Publishing出版，版权日期为2007年。作者通过实践导向的教学方法，旨在帮助读者在短短21...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值