java的成长之路
封面是飞佬在上海拍的图片，觉得很不错就拿来用一下，嘿嘿！
数组
java中的二维数组是可以自行添加列数的
数组.length = 数组长度。
一维数组的常用方法
package java_study;
import java.util.Scanner;
public class study01 {
public static void main(String[] args){
// 数组的常用方法
int[] arr = new int[5];//开辟一个含有五个空间的数组
//int[] arr;
//arr = new int[5];//效果等同上述
for(int i = 0; i < 5; i ++ )
arr[i] = i + 1;
for(int i = 0; i < arr.length; i ++ )
System.out.println("数组的值为：" + arr[i]);
}
}
二维数组的常用方法
package java_study;
import java.util.Scanner;
public class study01 {
public static void main(String[] args){
// 数组的常用方法
int[][] arr = new int[5][5];//二维数组
//int[][] arr;
//arr = new int[5][5];//效果等同上述
for(int i = 0; i < 5; i ++ )
arr[i][i] = i + 1;
for(int i = 0; i < arr.length; i ++ )
System.out.println("数组的值为：" + arr[i][i]);
}
}
java中二维数组的特殊之处，可以不确定列数
package java_study;
import java.util.Scanner;
public class study01 {
public static void main(String[] args){
// 写一个二维数组的列数不确定情况
int[][] arr = new int[3][];
//此时还未开辟列的空间
for(int i = 0, n = 1; i < n && n != 4; i ++ , n ++ )
{
//给列数开辟空间
arr[i] = new int[i + 1];
for(int j = 0; j < arr[i].length; j ++ )
{
arr[i][j] = j + 1;
}
}
for(int i = 0; i < arr.length; i ++ )
{
for(int j = 0; j < arr[i].length; j ++ )
{
System.out.print(arr[i][j]);
}
System.out.println();
}
}
}
//1
//1 2
//1 2 3
下面介绍一个二维数组自行添加列数的实例
打印杨辉三角
package java_study;
import java.util.Scanner;
public class study01 {
public static void main(String[] args){
// 写一个杨辉三角
Scanner s = new Scanner(System.in)
int row = s.nextInt()
int[][] arr = new int[row][];
for(int i = 0; i < row; i ++ )
arr[i] = new int[i + 1];
arr[0][0] = 1;
arr[1][0] = 1;
arr[1][1] = 1;
for(int i = 2; i < row; i ++ )
{
for(int j = 0; j < arr[i].length; j ++ )
{
if(j == 0 || j == arr[i].length - 1) arr[i][j] = 1;
else arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
}
}
//打印杨辉三角
System.out.println("打印杨辉三角：");
for(int i = 0; i < row; i ++ )
{
for(int j = 0; j < arr[i].length; j ++ )
{
System.out.print(arr[i][j] + "\t\t\t");
}
System.out.println();
}
}
}
我这里输入的是十，所以就是十行，运行结果：
类与对象
访问修饰符 属性类型 属性名; 四种基本访问修饰符：public、protected、默认、private
一个类只能new 一次，在堆中分配空间之后就会进行默认初始化
访问修饰符就是限制方法使用的范围，如果不写有默认访问符。
引用传递的实质其实是在另一个函数中创建一个相同名称的变量并且都指向相同的地址，你在此时将这个变量存储数据的地址指向空，并不会影响到原有的变量指向的地址。并且你在函数中可以进行二次分配空间(地址不同)
下面是一个例子
package java_study;
public class study01 {
public static void main(String[] args){
People p = new People();
p.age = 10;
p.name = "zhangsan";
System.out.println("张三的年龄为："+ p.age + "岁");
p.test(p);
System.out.println("改变后张三的年龄为："+ p.age + "岁");
p.testTwo(p);
System.out.println("再次改变后张三的年龄为："+ p.age + "岁");
}
}
class People{
String name;
int age;
public void test(People p){
p = null;
}public void testTwo(People p){
p = new People();
p.age = 20;
}
}
大家都知道对象是引用传递，可能有些人会觉得第二个输出会抛出异常，第三个是20岁，但结果可能会不同。
递归游戏
斐波那契数列和猴子吃桃问题
package java_study;
import java.util.Scanner;
public class study02 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.print("\n请输入一个你需要求的桃子数：");
int input = s.nextInt();
Judge judge = new Judge();
// System.out.println("斐波那契数为："+ judge.fibonacci(input));
int nums = 1;// 桃子最后一天剩余量
System.out.println("总共的桃子数为："+ judge.eatfruit(input, nums));
}
}
//斐波那契数列 ： 1 1 2 3 5 8 13 ...
class Judge {
public int fibonacci(int n) {
if(n == 1) return 1;
if(n == 2) return 1;
return fibonacci(n - 1) + fibonacci(n - 2);
}
public int eatfruit(int day, int nums) {
// 输入天数
if(n == 0) return nums;
nums = (nums + 1) * 2;
return eatfruit(day - 1, nums);
}
}
走迷宫问题
package java_study;
public class study02 {
public static void main(String[] args) {
Judge judge = new Judge();
int[][] map = new int[8][8];
judge.initMaze(map);
judge.printMazeMap(map);
judge.goOutMaze(map, 1, 1);
}
}
class Judge {
public void initMaze(int[][] map) {
for(int i = 0;i < 8; i++ )
{
/*
* 1为障碍物，0为可通过
* 游戏规则：从 1.1位置出发 到达 6.6即可成功！
* */
map[0][i] = 1;//将四周作为墙;
map[7][i] = 1;
map[i][0] = 1;
map[i][7] = 1;
}
//设置障碍物
map[2][3] = 1;
map[2][4] = 1;
map[3][3] = 1;
map[4][3] = 1;
map[4][1] = 1;
map[6][4] = 1;
map[5][4] = 1;
}
public void printMazeMap(int[][] map)
{
for(int i = 0;i < 8; i++ )
{
for(int j = 0; j < 8 ; j ++ )
{
System.out.print(map[i][j]);
if(j != 7) System.out.print(" | ");
}
System.out.println();
}
}
public boolean goOutMaze(int[][] map, int x, int y) {
if(map[6][6] == 2) {
System.out.println("~~~~~~~~~您已成功走出迷宫！");
return true;
}else if(map[x][y] == 0){
//先假定这个点是最终结果
map[x][y] = 2;
System.out.println("当前位置为：" + x + "," + y);
if(goOutMaze(map, x + 1, y)) return true;
else if(goOutMaze(map, x, y + 1)) return true;
else if(goOutMaze(map, x -1, y)) return true;
else if(goOutMaze(map, x, y - 1)) return true;
else {
//如果四个方向都无法达到就说明他不是最终点
map[x][y] = 3;
return false;
}
}else return false;//如果这个点为1 ， 3说明这个点为障碍物或者已经走过并且无法通过
}
}
迷宫形状
游戏结果：
汉诺塔问题
package java_study;
import java.util.Scanner;
public class study03 {
public static void main(String[] args){
Scanner s = new Scanner(System.in);
System.out.print("请输入盘子的数量：");
int input = s.nextInt();
Hanoi h = new Hanoi();
h.hanoi(input, 'A', 'B', 'C');
}
}
class Hanoi {
public void hanoi(int nums, char A, char B, char C){
if(nums == 1){
System.out.println(A + " -> " + C);
}else {
// 先将A盘中的所有盘子看作两部分，先将第一部分移动到B盘中并且借助于C
hanoi(nums - 1, A, C, B);
System.out.println(A + " -> " + C);
// 将B盘中的所有盘子移动到C中并且借助于A
hanoi(nums - 1, B, A, C);
}
}
}
输出结果：
总结：学习是一个循序渐进的过程，动手是找到漏洞的最好办法。
————————————
最近有个端午节活动，虽然发布的有点晚了，但是也不能一点也没有端午节的元素，所以我直接用多种语言打印一个端午节快乐吧！
C/C++
#include<bits/stdc++.h>
using namespace std;
int main() {
printf("Duan Wu Jie Happy!\n");
cout << "端午节快乐!";
return 0;
}
Go
package main
import ( "fmt" )
func main(){
fmt.Println("端午节快乐!")
}
JavaScript
console.log("端午节快乐!");
Java
package main
public class duanWu{
public static void main(String[] args){
System.out.println("端午节快乐!");
}
}
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
