java从入门到入土第9天

已于 2024-05-08 10:02:21 修改
阅读量168 收藏
点赞数 3
分类专栏： java入门到入土 文章标签： java
于 2024-05-06 20:44:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_yin0/article/details/138507698
版权

Day09

package com.qf.test01;

public class Person {
	
	//属性
	String name;
	char sex;
	int age;
	
	//构造方法 -- 无参构造
	public Person(){
		System.out.println("Person的无参构造");
		this.name = "彭于晏";
		this.sex = '男';
		this.age = 43;
	}
	
	//构造方法 -- 有参构造
	public Person(String name,char sex,int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	//成员方法
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
	
	//静态方法
	public static void method(){
		System.out.println("静态方法");
	}
}


package com.qf.test01;

public class Test01 {
	/**
	 * 知识点：构造方法/构造器
	 * 
	 * 含义：与类名相同，且没有返回项的方法
	 * 作用：
	 * 		1.和new关键字一起表示创建对象
	 * 		2.初始化数据
	 * 
	 * 注意：
	 * 		1.如果写了有参构造，系统不会默认实现无参构造
	 * 		2.构造方法可以重载
	 * 
	 * 经验：写了有参构造，自己把无参构造写上
	 * 	
	 */
	public static void main(String[] args) {
		
//		Person p = new Person();
//		p.name = "侯小康";
//		p.sex = '男';
//		p.age = 23;
		
		Person p = new Person("侯小康", '男', 23);
		
		System.out.println(p.name);
		System.out.println(p.sex);
		System.out.println(p.age);
		
		p.eat();
		p.sleep();
	}
}


package com.qf.test02;

public class Person {
	
	//属性
	String name;
	char sex;
	int age;
	
	//构造方法 -- 无参构造
	public Person(){
		//this()：在构造方法的第一句调用另外一个构造方法
		this("彭于晏", '男', 46);
		System.out.println("Person的无参构造");
	}
	
	//构造方法 -- 有参构造
	public Person(String name,char sex,int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	//成员方法
	public void eat(){
		
		//this.属性：调用本对象的成员属性
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		//this.属性：调用本对象的成员属性
		System.out.println(this.name + "睡觉觉");
	}
	
	public void writerCode(){
		//this.属性：调用本对象的成员属性
		System.out.println(this.name + "写代码");
	}
	
	public void study(){
		//this.方法：调用本对象的成员方法
		this.eat();
		this.writerCode();
		this.sleep();
	}
	
	//静态方法
	public static void method(){
		System.out.println("静态方法");
	}
}


package com.qf.test02;

public class Test01 {
	/**
	 * 知识点：this
	 * 含义：this表示调用该方法的对象
	 * 	
	 * 作用：
	 * 		1.this.属性：调用本对象的成员属性
	 * 		2.this.方法：调用本对象的成员方法
	 * 		3.this()：在构造方法的第一句调用另外一个构造方法
	 */
	public static void main(String[] args) {
		
		Person p = new Person();
		
		p.study();
	}
}


package com.qf.test03;

public class A {

	private String attr = "A类的私有化属性";
	
	private void method01(){
		
		System.out.println(this.attr);
		System.out.println("A类的私有化方法");
	}
	
	public void method02(){
		method01();
	}
	
}


package com.qf.test03;

public class Test01 {
	/**
	 * 知识点：private
	 * 理解：private是访问修饰符的一种，表示私有
	 * 扩展：访问修饰符可以修饰属性和方法
	 * 
	 * 作用：
	 * 		1.修饰属性：该属性不能在类的外面使用
	 * 		2.修饰方法：该方法不能在类的外面使用
	 * 
	 * 应用场景：
	 * 		1.不想让外界直接调用的属性就使用private修饰
	 * 		2.不想让外界直接调用的方法就使用private修饰
	 */
	public static void main(String[] args) {
		
		A a = new A();
		
		a.method02();
	}
}


package com.qf.test04;

import java.time.LocalDateTime;

public class User {

	private String username;
	private String password;
	private double money;
	
	public User() {
	}

	public User(String username, String password, double money) {
		this.username = username;
		this.password = password;
		this.money = money;
	}
	
	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public void setMoney(double money){
		//额外的功能
		double num = money - this.money;
		System.out.println(LocalDateTime.now() + "设置了金额：" + num);
		
		this.money = money;
	}
	
	public double getMoney(){
		return this.money;
	}
}


package com.qf.test04;

public class Test01 {
	/**
	 * 知识点：封装
	 * 概念：将属性封装到对象的内部，通过get/set方法去操作属性
	 * 步骤：
	 * 		1.私有化属性
	 * 		2.添加get（获取）/set（设置）方法
	 * 好处：
	 * 		将属性封装到对象的内部，外界不能直接操作属性
	 * 		必须通过get/set方法去操作属性
	 * 		可以在get/set方法中做额外的功能
	 * 经验：属性都必须封装
	 * 
	 * 
	 * 需求：模拟银行用户操作金额的过程
	 * 分析：怎么操作金额？
	 * 		1.设置金额
	 * 		2.获取金额
	 * 
	 *  经验：操作属性 --> 设置和获取		
	 *
	 */
	public static void main(String[] args) {
		
		User user = new User("1445584980", "123123", 2000);
		
		//获取金额 -- 2000 --> 获取金额
		//减200  --- 1800
		//将1800赋值给金额属性 --> 设置金额
//		user.money = user.money - 200;
//		System.out.println(user.money);//1800
		
		user.setMoney(user.getMoney() - 200);
		System.out.println(user.getMoney());
	}
}


 package com.qf.test;

public class Gobang {

	//棋盘长度
	private int length = 20;
	//棋盘容器
	private String[][] gobang = new String[length][length];
	//棋盘坐标
	private String[] nums = {"⒈","⒉","⒊","⒋","⒌","⒍","⒎","⒏","⒐","⒑","⒒","⒓","⒔","⒕","⒖","⒗","⒘","⒙","⒚","⒛"};
	//棋盘符号
	private String add = "┼";
	private String black = "●";
	private String white = "○";
	
	public Gobang() {
		this.init();
		this.printGobang();
	}
	
	//初始化棋盘
	private void init(){
		for (int i = 0; i < gobang.length; i++) {
			for (int j = 0; j < gobang[i].length; j++) {
				if(j == length-1){//每行的一列，设置行数

					gobang[i][j] = nums[i];
					
				}else if(i == length-1){//最后一行，设置列数
					
					gobang[i][j] = nums[j];
					
				}else{
					gobang[i][j] = add;
				}
			}
		}
	}
	
	//打印棋盘
	public void printGobang(){
		for (String[] strings : gobang) {
			for (String str : strings) {
				System.out.print(str);
			}
			System.out.println();
		}
	}
	
	//判断坐标是否在棋盘内
	public boolean isIndexOutOfGobang(int x,int y){
		if(x<0 || x>length-2 || y<0 || y>length-2){
			return false;
		}
		return true;
	}
	
	//判断坐标上是否有棋子
	public boolean isPiece(int x,int y){
		if(!gobang[x][y].equals(add)){
			return false;
		}
		return true;
	}
	
	//落子
	public int play(int x,int y,boolean flag){
		
		if(!isIndexOutOfGobang(x, y)){
			return -1;
		}
		
		if(!isPiece(x, y)){
			return -2;
		}
		
		String piece = (flag)?black:white;
		gobang[x][y] = piece;
		return 1;
	}
	
}


package com.qf.test;

import java.util.Scanner;

public class Test {

	/**
	 * 知识点：面向对象版五子棋
	 */
	public static void main(String[] args) {
		
		Gobang gobang = new Gobang();
		
		Scanner scan = new Scanner(System.in);
		boolean flag = true;//true-黑子  false-白子
		
		while(true){
			
			//输入坐标
			System.out.println("请" + ((flag)?"黑":"白") + "子输入坐标：");
			int x = scan.nextInt() - 1;//-1是因为用户看到的界面是坐标(从1开始)，数组是下标(从0开始)
			int y = scan.nextInt() - 1;//-1是因为用户看到的界面是坐标(从1开始)，数组是下标(从0开始)
			
			//落子
			int play = gobang.play(x, y, flag);
			if(play == -1){
				System.out.println("坐标错误 - 坐标超出棋盘范围，请重新输入");
				continue;
			}else if(play == -2){
				System.out.println("坐标错误 - 坐标上已有棋子，请重新输入");
				continue;
			}
			
			//打印棋盘
			gobang.printGobang();
			
			//置反
			flag = !flag;
		}		
	
		
		
	}
}


package com.qf.test05;

/**
 * 编写一个类的步骤：
 *		1.属性
 *		2.私有化属性
 *		3.构造方法 - 无参构造、有参构造
 *		4.get/set的
 *		5.独有的方法 -- eat()、sleep()...
 */
public class Person {

	private String name;
	private char sex;
	private int age;
	
	static String star = "星球";
	
	public Person() {
	}

	public Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}


package com.qf.test05;

public class Test01 {
	/**
	 * 知识点：分包
	 * 理解：最基本的功能就是防止类的重名
	 * 项目中的功能：做类的分类（一个项目有成千上万的类，需要分包做管理）
	 * 		com.qf.utils/tools -- 工具类的包
	 * 		com.qf.pojo/entity/vo -- 实体类的包
	 * 		com.qf.map/mapper -- 操作数据库类的包
	 * 		com.qf.biz/service -- 操作业务类的包
	 * 命名规范：网络倒序
	 * 		com/net/cn.公司名.项目名/功能名
	 * 
	 * 知识点：static
	 * 理解：静态的
	 * 作用：
	 * 		1.静态属性
	 * 		2.静态方法
	 * 		3.静态代码块
	 * 
	 * 知识点：static修饰属性
	 */
	public static void main(String[] args) {
		
		Person p1 = new Person();
		Person p2 = new Person();
		
		p1.setName("侯小康");
		p2.setName("波多野结衣");
		System.out.println(p1.getName());//侯小康
		System.out.println(p2.getName());//波多野结衣
		
//		p1.star = "地球";
//		p2.star = "火星";
//		System.out.println(p1.star);
//		System.out.println(p2.star);
		
		//注意：静态属性属于每个对象共享的属性，直接使用类名调用
		Person.star = "地球";
		System.out.println(Person.star);
	}
}


package com.qf.test06;

import com.qf.array.MyArrays;

public class Test01 {
	/**
	 * 知识点：static修饰方法
	 * 应用场景：工具类（该类中的方法都是静态的）
	 */
	public static void main(String[] args) {
		
		int[] arr = {5,72,9,4,21,1,6,3,81};	
		
		//排序 - 1,3,4,5,6,9,21,72,81
		MyArrays.sort(arr);
		
		//查找
		//返回值规则：搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 
		//返回值规则：如果元素包含在数组中，返回下标;否则，(-(插入点) - 1) 
		int index = MyArrays.binarySearch(arr,30);
		System.out.println("查找到元素的下标为：" + index);
		
		//拷贝数组 - [1, 3, 4, 5, 6, 9, 21, 72, 81, 0, 0, 0, 0, 0, 0]
		int[] newArr1 = MyArrays.copyOf(arr,15);
		
		//拷贝数组区间 - [4, 5, 6, 9, 21, 72, 81, 0, 0]
		int[] newArr2 = MyArrays.copyOfRange(newArr1,2,11);//(目标数组，开始下标-包含，结束下标-排他)
		
		//替换所有元素 - [888, 888, 888, 888, 888, 888, 888, 888, 888]
		MyArrays.fill(newArr2,888);
		
		//替换区间元素
		MyArrays.fill(newArr2,2,4,666);//(目标数组，开始下标-包含，结束下标-排他，替换元素)
	
		//将数组转换为字符串
		String str = MyArrays.toString(newArr2);
		System.out.println(str);
	}
}


package com.qf.test07;

public class A {
	//成员属性
	String str1;
	
	//静态属性
	static String str2;
	
	//静态代码块：类加载到方法区时调用，可以初始化静态属性
	static{
		str2 = "ccc";//A.str2 = "bbb";
		System.out.println("A类的静态代码块：" + str2);
	}
	
	//代码块：创建对象时优先于构造方法调用，可以初始化成员属性和静态属性
	{
		str1 = "bbb";//this.str1 = "bbb";
		str2 = "bbb";//A.str2 = "bbb";
		System.out.println("A类的代码块：" + str1 + " -- " + str2);
	}
	
	//构造方法：创建对象时调用，可以初始化成员属性和静态属性
	public A() {
		str1 = "aaa";//this.str1 = "aaa";
		str2 = "aaa";//A.str2 = "aaa";
		System.out.println("A类的构造方法：" + str1 + " -- " + str2);
	}
}


package com.qf.test07;

public class Test01 {
	/**
	 * 知识点：静态代码块
	 * 
	 * 经验：
	 * 		初始化成员属性一般在构造方法中进行
	 * 		初始化静态属性一般在静态代码块中进行
	 * 
	 */
	public static void main(String[] args) {
		
		A a1 = new A();
		A a2 = new A();
		
	}
}


package com.qf.array;

/**
 * 世上最牛逼的数组工具类
 * @author 侯小康
 * @version 1.0
 */
public class MyArrays {

	/**
	 * 数组的排序
	 * @param arr 目标数组
	 */
	public static void sort(int[] arr){
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	
	/**
	 * 数组的查找
	 * @param arr 目标数组
	 * @param key 要搜索的键
	 * @return 如果元素包含在数组中，返回下标;否则，(-(插入点) - 1) 
	 */
	public static int binarySearch(int[] arr,int key){
		int start = 0;
		int end = arr.length-1;
		while(start <= end){
			int mid = (start+end)/2;
			if(key < arr[mid]){
				end = mid-1;
			}else if(key > arr[mid]){
				start = mid+1;
			}else{
				return mid;
			}
		}
		return -start-1;
	}
	
	/**
	 * 拷贝数组
	 * @param arr 目标数组
	 * @param newLength 拷贝长度
	 * @return 新数组
	 */
	public static int[] copyOf(int[] arr,int newLength){
		
		int copyLen = arr.length;
		if(copyLen > newLength){
			copyLen = newLength;
		}
		
		int[] newArr = new int[newLength];
		
		for (int i = 0; i < copyLen; i++) {
			newArr[i] = arr[i];
		}
		return newArr;
	}
	
	/**
	 * 拷贝区间数组
	 * @param arr 目标数组
	 * @param start 开始下标-包含
	 * @param end 结束下标-排他
	 * @return 新数组
	 */
	public static int[] copyOfRange(int[] arr,int start,int end){
		
		int length = end-start;
		int[] newArr = new int[length];
		
		int index = 0;
		for (int i = start; i < end; i++) {
			newArr[index++] = arr[i];
		}
		return newArr;
	}
	
	/**
	 * 替换区间元素
	 * @param arr 目标数组
	 *  @param start 开始下标-包含
	 * @param end 结束下标-排他
	 * @param key 需要替换的键
	 */
	public static void fill(int[] arr,int start,int end,int key){
		for (int i = start; i < end; i++) {
			arr[i] = key;
		}
	}
	
	/**
	 * 替换全部元素
	 * @param arr 目标数组
	 * @param key 需要替换的键
	 */
	public static void fill(int[] arr,int key){
		fill(arr, 0, arr.length, key);
	}
	
	/**
	 * 获取数组的字符串表示
	 * @param arr 目标数组
	 * @return 数组字符串
	 */
	public static String toString(int[] arr){
		
		String str = "[";
		
		for (int element : arr) {
			if(str.length() != 1){
				str += ",";
			}
			str += element;
		}
		str += "]";
		return str;
	}
}

1.构造方法（概念、内存图）

2.this
this.属性
this.方法
this()

3.private
修饰属性、修饰方法

4.封装
1.私有化属性
2.get/set方法

5.面向对象版本的五子棋

6.static修饰属性、修饰方法、静态代码块

作业：
1.知识点梳理文档 – 手写
2.代码编写三遍
3.画内存图
4.课后作业：小明把大象装进冰箱
5.复习：之前所有的知识点
6.预习：继承、重写、super、抽象类及抽象方法

提升作业：把面向对象版本的五子棋判断输赢实现！！！

Java学习路线从入门到入土
web15185420056的博客
05-29 165
Java学习路线从入门到入土 Java学习路线从入门到入土 Java学习路线从入门到入土 简介 Java基础课程 第一阶段 第一部分：Java开发介绍 第二部分：Java数组 第三部分：Java面向对象 第四部分：常用基础类 第五部分：集合 第六部分：IO流 第七部分：多线程 第八部分：异常 第九部分：网络 第十部分：反射 第十一部分：数据结构与算法 JavaWeb课程 第二阶段 内容 第一部分：HTML5 第二部分：CSS3 第三部分：JavaScript 第四部分：MyS
java从入门到入土第1天
xiao_yin0的博客
04-22 680
JavaEE：就是服务端，接受来自客户端(前端)的请求，利用响应返回给客户端数据的技术目的：做饭工具：锅碗瓢盆环境：厨房目的：编写Java程序工具：JDK（Java开发工具包）环境：JRE（Java运行时环境）前言：上课时间、上课规矩、学习方法软件开发基础Java环境搭建：安装JDK和JRE，环境变量适配(JAVA_HOME、Path)编写第一个Java程序。
java从入门到入土第2天
xiao_yin0的博客
04-23 851
理解：IDE（编码环境），就是写代码的工具升级：记事本 -> nodepad++ -> eclipse -> IDEAIDE - 编码环境编码问题关键字及关键字变量及注意事项基本数据类型（byte、short、int、long、float、double、char、boolean）基本数据类型的转型。
java从入门到入土第4天
xiao_yin0的博客
04-25 396
6.预习：while、do-while、特殊的流程控制语句。1.转义字符：具有特殊意义的字符本身。数字字面量、字面值常量、final。5.复习：运算符的面试题、特殊点。3.Java执行语句的分类。1.知识点的梳理文档s。5.switch分支。
java从入门到入土第5天
xiao_yin0的博客
04-26 729
6.提升作业：分别使用for循环、while循环实现。5.预习：方法、数组、面向对象。1.嵌套for循环 – 重要。3.do-while循环。5.特殊的流程控制语句。4.复习：本周所有内容。6.万年历 – 重要。1.知识点的梳理文档。
java从入门到入土第3天
xiao_yin0的博客
04-24 570
1.算数运算符（+、-、*、/、%、++、–）注意：特殊点和面试题2.赋值运算符（=、+=、-=、*=、/=、%=）注意：复合赋值的底层公式3.关系运算符（==、!注意：关系运算符的结果都是boolean类型的值4.字符串拼接符（+）5.Scanner类注意：感受面相对象的思想6.逻辑运算符（&、&&、|、||、^、!注意：逻辑运算符的结果都是boolean类型的值7.三目运算符注意：语法结构、返回值规则8.位运算符（&、|、^、、>>>）
java从入门到入土第8天
xiao_yin0的博客
05-04 301
3.预习：面向对象 – 构造方法、this、private、封装、static、继承、super、重写、访问修饰符、抽象类及抽象方法、接口、多态、对象转型、内部类。2.复习：之前所有的内容。
java从入门到入土第6天
xiao_yin0的博客
04-28 146
带返回值的方法（方法声明时的类型、return后接的数据）1.知识点的梳理文档（方法.md、数组.md）2.方法的重载（概念、条件、好处、应用场景）3.画内存图（手画2遍、拍照发到QQ群里）3.方法的递归（概念、找出口、找规律）带参数的方法（形参和实参）5.复习：上周所有内容。无参数无返回值的方法。4.方法版本的万年历。
java从入门到入土第7天
xiao_yin0的博客
04-29 94
【代码】java从入门到入土第7天。
ElasticSearch详细笔记（ 从入门到入土）
GOV_D的博客
04-18 3381
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1.ElasticSearch概述1.1 Elasticsearch 是什么1.2 全文搜索引擎1.3 Elasticsearch And Solr2. ElasticSearch安装2.1 下载和安装2.2 可能存在的问题2.3 RESTful3. ES的基本使用3.1 数据格式3.2 分片概念3.3 索引操作（1）创建索引（2） 查看所有索引（3） 查看单个索引（4） 删除索引3.4 文档操作（1）创建文档（2） 查.
Git使用 从入门到入土 收藏吃灰系列(四) Git工作原理
张时贰的博客
02-04 1092
文章目录一、前言一、Git基本理论(核心)1.1工作区1.2工作流程 一、前言 参考安装Git 详细安装教程 参考视频B站 Git最新教程通俗易懂，这个有点长，感觉讲的精华不多 参考视频『Git』知道这些就够了_哔哩哔哩_bilibili，这个精华多，推荐看这个 参考视频7小时学会Git 基础全套完整教程（从入门到精通）_哔哩哔哩_bilibili，这个虽然长，但是他偏实践，对小白友好，特别有意思 附一个Git动画学习网站 Git教程 - 廖雪峰的官方网站 (liaoxuefeng.com) 讲讲小张的
从入门到入土：Lambda完整学习指南，包教包会！
Java笔记虾
12-09 5689
什么是Lambda表达式 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda表达式还增强了集合库。 Java Lambda表达式的一个重要用法是简化某些匿名内部类（Anonymous Classes）...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 642
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 784
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 262
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 402
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
GEMM优化（待更新）
qq_62704693的博客
11-03 750
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 271
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
java学习怎么从入门到入土
03-31
作为一个 AI，我不能协助您在学习过程中“入土”，因为我的宗旨是帮助人们更好地学习和成长。以下是一些建议，可以帮助您更好地学习 Java。 1. 学习基础：首先，您需要了解 Java 的基础知识，例如变量、数据类型、控制结构、循环等。可以通过阅读书籍或在线教程来学习这些基础知识。 2. 练习编程：学习编程最好的方法是通过编写代码来进行实践。可以使用练习题或者参与开源项目来锻炼编程能力。 3. 学习面向对象编程：Java 是一种面向对象编程语言，因此学习面向对象编程是非常重要的。学习类、对象、继承、封装、多态等概念，并且在实践中应用这些概念。 4. 学习 Java 库和框架：Java 有许多库和框架，可以帮助您更高效地编写代码。例如，学习 Java 的标准库、Spring 框架等。 5. 继续深入学习：Java 是一种非常广泛应用的编程语言，因此需要不断地深入学习并跟上技术的发展。可以学习 Java 8 新特性、Java EE、Android 开发等。 总之，学习 Java 需要不断地努力和实践，并且需要持续学习并跟上技术的发展。祝您学习愉快！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值