＜1＞java自学篇

已于 2022-06-20 16:38:58 修改
阅读量256 收藏 1
点赞数 1
文章标签： java 开发语言
于 2022-06-14 15:46:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49141056/article/details/125279546
版权

java自学篇

                            -----师从----java1234小锋

Java

一、java前篇

1、 了解java的基本信息

2、安装java环境

3、完成一个java实列

// 输出一个hello word
system.out.println("helloword");

二、java语法

1、java的注释：

//  单行注释
/* 多行注释*/  //   ctrl+/ 
/**.文档注释.*/

2、java标识符命名

命名规则：数字、字母、下划线、&符号，java关键字不能作为标识符。不能数字作为开头，[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nUsc7WV5-1655192536158)(D:\java1234\java1234笔记\java1234笔记截图\image-20220508150022678.png)]

3、java基本数据类型

在Java中共有八种基本数据类型，它们分别是以下几种类型：

数据类型描述占用字节取值范围默认值
int整型，用于存储整数4个字节-2147483648~21474836470
byteJava中最小的数据类型1个字节-128~1270
short短整型2个字节-32768~327170
long长整型8个字节-263~263-10L
float浮点型，用于存储带小数点的数字4个字节/0.0f
double双精度浮点型，用于存储带有小数点的数字8个字节/0.0d
char字符型，用于存储单个字符2个字节0~65535空
boolean布尔类型，用于判断真或假1个字节仅有两个值，即true、falsefalse
//定义一个int变量
		int a=1;
		System.out.println("a="+a);
	//定义一个int类型的变量
		int b=2;
		System.out.println("b="+b);
// 定义一个byte变量
		byte c=1;
		System.out.println("c="+c);
// 定义一个short变量
		short d=2;
		System.out.println("d="+d);
// 定义一个long变量
		long e=5;
		System.out.println("e="+e);
System.out.println("-----------------------------------------");
		int a1=10;
		int a2=10;
		int a3;
		a3=a1+a2;
		System.out.println("a1+a2="+a3);
System.out.println("-----------------------------------------");
		int a4=1;
		int b4=2;
		int c4=3;
		int d4=4;
		int e4=5;
		int s;
		s=a4+b4+c4+d4+e4;
		System.out.println("a4+b4+c4+d4+e4="+s);
		//写法2
		int x=1+2+3+4+5;
		System.out.println("1+2+3+4+5="+x);
		


// 浮点类型
public static void main(String args[]){
		//定义一个float的类型变量
		//小数默认是double类型，所以我们必须家一个f，来表示float类型
		float f=0.1f;
		System.out.println("f="+f);
		
		//定义一个double类型的变量
		double d=1.2;
		System.out.println("d="+d);
		
		//获取float类型的最大值和最小值并且赋值给maxF和minF；
		float maxF=Float.MAX_VALUE;
		float minF=Float.MIN_VALUE;
		System.out.println("maxF="+maxF);
		System.out.println("minF="+minF);
			
	}

**4、**转义字符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EX11hyP4-1655192536159)(D:\java1234\java1234笔记\java1234笔记截图\image-20220508173453575.png)]

package com.java1234;

public class pro04 {
	public static void main(String args[]){
		//定义一个单字符
		char c1='A';
		char c2='b';
		char c3='3';
		System.out.println("c1="+c1);
		System.out.println("c2="+c2);
		System.out.println("c3="+c3);
		
		// 转义字符,如果需要保存一些特殊的字符，那么需要在特殊符号前加一个反斜杠“ \ ”,否则会被确定为非法字符 
		char c4='\'';
		char c5='\\';
		System.out.println(c4+""+c5);
		
        //使用Unicode表输出   \u开头，查表
		// https://www.cnblogs.com/whiteyun/archive/2010/07/06/1772218.html
		char c6='\u6635';
		char c7='\u6685';
		char c8='\u6695';
		System.out.println(c6+""+c7+""+c8);
        
        
        // 定义一个布尔类型的变量b
        boolean b1=true;
        System.out.println("b1="+b1);
         
        // 定义一个布尔类型的变量b2
        boolean b2=false;
        System.out.println("b2="+b2);
		
	}

}

5、数据类型转换；

5.1基本类型的类型转换分为 ：自动类型转换和强制类型转换

public class pro05 {
	public static void main(String args[]){
		// 自动类型转换 
		int a=1;
		long b;
		b=a;
		System.out.println(b);
		// 强制类型转换
		double a1=1.365;
		float a2;
		// a2=a1;  这种写法，a1的值给a2时候，类型不能自动转换，所以才会如此，
		// 数据类型强制转换：在需要转换的数据前加上转换的类型
		a2=(float)a1;
		System.out.println(a2);
		
	}

}

6、运算符

Java运算符与表达式-自增与自减运算符符号：++（自增）； --(自减)

a++是先操作后加1；++a是先加1后操作

  public static void main(String[] args) {
        int a1=1;
        // a1++; 表示先做赋值操作，后自增
        int b1=a1++;
        System.out.println("b1="+b1);
        System.out.println("a1="+a1);
         
        System.out.println("===================");
        // ++a2；表示先自增，后做赋值操作
        int a2=1;
        int b2=++a2;
        System.out.println("b2="+b2);
        System.out.println("a2="+a2);
         
    }


public class pro07 {
	public static void main(String[] args) {
		// && 与，前后两个操作数的结果都必须相同，为true，否则返回为false
		boolean b1=(5>6)&&(6>7);//false 这个相当于短路了，前面部分为false，无论后面为TRUE为false结果偶读为false
		boolean b2=(6>3)&&(7>6);// true
		boolean b3=(6>3)&&(7>8);// false
		System.out.println("b1="+b1);
		System.out.println("b2="+b2);
		System.out.println("b3="+b3);
		
		// & 不短路与 
		boolean a1=(5>6)&(7>8);
		System.out.println("a1="+a1);
		// || 或，只要一个为true ，返回的结果都为true，一真则真。
		boolean a2=(6>5)||(6>7);
		System.out.println("a2="+a2);
		// | 不短路或 ，前后表达式都会执行，
		boolean a3=(4>5)|(6>5);
		System.out.println("a3="+a3);
		// ! 非，表达式的结果为true，则返回false，否则返回true。
		boolean c1=!(5>6);
		System.out.println("c1="+c1);
		 // ^ 异或 ，当两个操作数不相同时返回true，相同的时候返回false
		boolean c2=(6>5)^(8>7);
		System.out.println("c2="+c2);
		
		// 关系运算符
		  int a=2;
	      int b=3;
	        // >大于
	        System.out.println(a+">"+b+":"+(a>b));
	        // <小于
	        System.out.println(a+"<"+b+":"+(a<b));
	        // >=大于等于
	        System.out.println(a+">="+b+":"+(a>=b));
	        // <=小于等于
	        System.out.println(a+"<="+b+":"+(a<=b));
	        // ==等于
	        System.out.println(a+"=="+b+":"+(a==b));
	        // !=不等于
	        System.out.println(a+"!="+b+":"+(a!=b));
		// 三目运算符"
		String  z1=2>3?"表达式是真":"表达式是假";
		System.out.println(z1);
		
		boolean z2=(6>5)&&(9>8)?true:false;
		System.out.println(z2);
	}

}

7、java的选择语句

java中的选择语句用if…else和switch来实现，

package com.java1234;

import java.util.Scanner;
import java.util.*;

public class pro08 {
	public static void main(String[] args) {
		int a=-2;
		// if 
		if(a>0){
			System.out.println(a+":是正数");
		}
		// if else 
		if(a>0){
			System.out.println(a+":是正数");
		}else if(a<0||a!=0){
			System.out.println(a+":是负数");
		}
		// if ...else if ...else
		if(a>0){
			System.out.println(a+":是正数");
		}else if(a<0){
			System.out.println(a+":是负数");
		}else{
			System.out.println("这个数为："+a);
		}
		// switch选择语句  不仅仅支持判断int还是支持判断string'类型
		// switch语句在使用的时候，每一个case后面写完都必须写一个break的结束语句，在最后的default的
		//default相当于if-else的else。efault结构是可选的。位置灵活，可放在末尾，可放在开头，也可放在几个case中间。
		//先看case,再看default，看完default再往下走。不想往下走加上break。
		//使用官方提供得scanner从控制台获取到一个数据
		// Scanner  对象名字(在自己使用时候自己取任意的) =new Scanner(System.in);
		System.out.println("请输入一个数字：");
		Scanner  s =new Scanner(System.in);
		int b = s.nextInt();
		switch(b){
		case 1:{
			System.out.println("输入的数为：1");
			break;
			}
		case 2:{
			System.out.println("输入的数为：2");
			break;
			}
		default:{
			if (b!=1||b!=2){
			int	x=b;
			System.out.println("输入的数为"+x);
			}	
		}
		}
	}

}

8、循环语句

public class pro10 {
	public static void main(String[] args) {
		//输出1-10；
		//while循环语句 先判断，后执行
		int i=1;
		int j=1;
		while(i<11){
			System.out.print(i+" ");
			i++;
		}
		System.out.println("---------------");
		/* do....whille语句；
		 * 先输出在判断*/
		do{
			System.out.print(j+" ");
			j++;
		}while(j<16);
		//for循环加for循环嵌套
		 for(int a=0;a<=5;a++){
			 for(int b=0;b<=5;b++){
				 System.out.print(" a="+a+" , b="+b);
			 }
			 System.out.println();
		 }
	}

}

9、循环语句的控制

break，结束当前循环；

public class Demo17 {
 
    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++){
                if(i==1){
                    break;
                }
                System.out.print("i="+i+" "+"j="+j+" ");
            }
            System.out.println();
        }
    }
}

// i=1的这行 没有输出；关键break 还有一个break标签 我们可以从内层跳到//外层，结束外层循环；比如我们只需要输出第一行  我们时候可以用标签实现：
public class Demo17 {
    public static void main(String[] args) {
        outer:
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++){
                if(i==1){
                    break outer;
                }
                System.out.print("i="+i+" "+"j="+j+" ");
            }
            System.out.println();
        }
    }
}

continue语句；

continue是结束当前循环，比如我们输出1到10 但是我们需要把3和6剔除，这时候我们可以用continue来实现：

public class Demo17 {
    public static void main(String[] args) {
        for(int i=1;i<=10;i++){
            if(i==3 || i==6){
                continue;//除了第三层和第六层，其他的都能出来，跳出当前循环体
            }
            System.out.print("i="+i+" ");
        }
    }
}

return语句；

return语句的话，比较狠，直接结束方法里的内容执行了。

public class Demo17 {
    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++){
                if(i==1){
                    return;// 只会打印第一层，
                }
                System.out.print("i="+i+" "+"j="+j+" ");
            }
            System.out.println();
        }
        System.out.println("执行到这里");
    }
}

10、java数组

数组的定义：type [ ]arrayName(数组名字) 或者 type arrayName(数组名字）[ ]

数组初始化：

1、静态初始化：type 数组名称[ ] =new type[ ]={type1,type2,…};

​ eg: int arr[ ]=new int[ ]={1,2,3}

​ 1.1当需要查看数组里面全部元素的时候，可以使用

​ for（int i；i<数组名字.length;i++）

int arr[]=new int[]={1,2,3}
//遍历出数组中的元素
for(int i=1;i<arr.length;i++){
    system.out.print(arr[i]);   // 数组的下标从0，开始 0,1，2
}

2、动态初始化：type 数组名字[ ]=new type[ length];

​ eg：int arr[ ] =new int[ 10];

int arr[]=new int[10];
//给数组赋值
arr[0]=10;
arr[3]=20;

3、二维数组：

​ 3.1、二维数组的定义方式：

// java二维数组的静态初始化：
type array[ ][ ]=new  type[][]{{},{},{}};,
//实列：
int arr[][]=new int[][]{{1,2},{1,2,3},{4,5,6}}
// java二维数组的动态初始化：
type array[][]=new type[length][length];
//实列：
int arr[][] =new int[5][6];

三、java面向对象

1、面向对象的基本概念；

​ 1.1、java面向对象的三大特性：封装、继承、多态。

​ 封装：我们可以类，类里有方法，属性，可以封装很多功能 仅仅对外暴露一些接口，来实现模块化，组建化，和安全性；

​ 继承：Java中的类可以继承，类似子女可以继承父母的东西；来实现可扩展；

​ 多态：Java中的父类接口可以指向子类实现的引用；

2、类与对象；

​ 2.1、创建一个类：注意事项，在创建类的时候，文件名要与类名相同，否则就会报错，类里面可以写对象的属性，比如一个人有名字，年龄，性别，身高，体重都是特殊的属性，他也有许多的动作行为叫做方法，比如说，说话，睡觉，走路，跑步等等。

​ 2.2、一个类可以有多个对象，

package com.java1234_3;

public class pro15_person {
	/*
	 * */
	// 定义一些属性
	String name;//姓名
	int age;//年龄
	String gender;//性别
	/*
	 * 定义一个方法
	 * 人会说话*
	 */
	public void speak(){
		System.out.println("我是"+name+"，我今年"+age+"岁");
	}
	public static void main(String[] args) {
		
		//定义一个类的对象并且给呀实列化
		//    类名 对象名 = 实列化 对象  
		pro15_person zs=new pro15_person();
		zs.name="张三";//给对象的name属性赋值
		zs.age=20;// 给对下的age属性赋值
		zs.speak();//调用对象的方法
	}

}

2.3、在方法中值传递的时候，仅仅改变在方法中的值，在方法里有效，在外部无效，外部使用时，外部的定义变量生效，

//方法里
// 假设这个类名叫cs
void  speak（int age）{
    system.out.print("我今年"+age+"了")
        age=24
}
//main函数里
public static viod main(string[] args){
    // 初始化一个对象
    cs cs1=new cs();
    int age=23;
    cs1.speak(age);
    sysytem.out.println(age);
    
}

2.4、方法的重载：在方法重载过程中参数类型一样，返回值类型不同，则不算重载。此时会提示方法重名，如：

//在这样的情况下会报错，
long add（int a int b){
    return a+b; 
}

// 正确示范；
// 方法的重载，参数个数不一样
int add（int a ,int b){
    system.out.print("方法一")
    return a+b;
}

int add（int a ,int b ,int c){
       system.out.print("方法二")
    return a+b+c;
}
// 定义了方法，进行对象实列化
public static void main(String[] args){
     Demo01 demo=new Demo01();
        System.out.println(demo.add(1, 2));
        System.out.println(demo.add(1, 2,3));
        System.out.println(demo.add(1, "3"));
}
//
// static方法与普通方法
	
	    void fun1(){
	        System.out.println("这是一个普通方法");
	    }
	     
	    static void fun2(){
	        System.out.println("这是一个静态方法");
	    }

 // 调用普通方法  对象.方法
	        demo.fun1();
	        // 调用静态方法 类名.方法
	        pro17.fun2();
	        demo.fun2();

2.5、递归：

​ 定义：设计一个出口，然后在使用过程中调用自己的方法，

package com.java1234.work;
/*
 *  F(1)=1, f(2)=1
    F(N)=F(N-1)+F(N-2)
     */
public class pro17_work {
	static long diGui(int n){
		
        if(n==1 || n==2)
	        {
	            return 1;
	        }
        return diGui(n-1)+diGui(n-2);
        
    }

    public static void main(String[] args) {
        System.out.println(pro17_work.diGui(3));
        
        
    }

}

2.5、构造方法this关键字

​ 构造方法分为有返回值的方法和没有返回值的方法，无参构造的名字与类名一样，无实际的意义。

​ 实例化对象的时候，String类型的默认值是null，int基本类型的默认值是0 ;

public class pro18 {
	private String name;
	private int age;
	// 含参构造，在实列化对象时候，传入实参，在赋值给属性
	// 无参构造，在实列化对象的时候，会自己生成一个空参构造，不起实际的意义。
	pro18(String name2,int age2){
		System.out.println("这是一个有参数的构造函数");
		name=name2;
		age=age2;
//	pro18(){
//		System.out.println("这是一个无参构造函数");
//	}
	}
	 public void say(){
		 System.out.println("我叫"+name+"，我今年"+age+"了");
	 }

	 public static void main(String[] args) {
		 pro18 r=new pro18("张珊",20);
		 r.say();
	}
}

this关键字、this表示当前对象

1，使用this调用本类中的属性；

2，使用this调用构造方法；

如何使用呢，那种情况下可以使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hDnkb4mO-1655192536160)(D:\java1234\java1234笔记\java1234笔记截图\image-20220528113446256.png)]

/**
 * 定义人类
 * @author user
 *
 */
public class People {
 
    // 定义属性 
    private String name; // 实例化对象时，默认值是null
    private int age; // 实例化对象时，默认值是0
     
    /**
     * 默认构造方法
     */
    /*People(){
        System.out.println("默认构造方法！");
    }*/
    /**
     * 有参数的构造方法
     * @param name
     * @param age
     */
    People(String name,int age){
        System.out.println("调用的是有参数的构造方法");
        this.name=name;
        this.age=age;
    }
     
    public void say(){
        System.out.println("我叫："+name+"，我今年："+age);
    }
     
    public static void main(String[] args) {
        // People people=new People();
        People people=new People("张三",20);
        people.say();
    }
}

若在构造方法中调用构造方法，使用this关键字也可以实现方法的调用。

eg：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YcnX0MIP-1655192536161)(D:\java1234\java1234笔记\java1234笔记截图\image-20220528113714683.png)]

2.6访问控制权限

​ 1.包括主要有 private(私有)， package(包访问权限)，protected(子类访问权限)，public(公共访问权限)

在private定义的属性，在使用时候可以采用get与set接口方法，才能够调用到私有属性，

​ 如：

public class pro19 {
	private int a;
    
// 快捷生成方式  在idea中是ctrl+o，在eclipse中是alt+shift+s 
	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}
}
 // ---------------------------------------------------
public class pro19_Test {
	public static void main(String[] args) {
		pro19 test=new pro19();
		//先设置a
		test.setA(2);
		//在获取a
		int a=test.getA();
		//在打印输出a
		System.out.println(a);
	}

}

2.在一个类里面需要加入其他包里的类时候，可以采用import导入

快捷方式：ctrl+shift+o 自动导入包，若 在后面有报错情况，查看导入的类中，是否有不可访问的权限，若有，则修改他的权限为public即可，实时开发过程中，自己小心。

2.7内部类

package com.java1234_3;


public class pro20 {
	public int b=10;
	// 内部类
	class Inner{
		public void show(){
			System.out.println(b);
		}
	}
	// 外部类
	public void show(){
		Inner inner=new Inner();
        //这里是调用的内部类的show
		inner.show();
	}
	public static void main(String[] args) {
	 pro20 test=new pro20();
	 //这里调用的是外部类的show方法
	test.show();
}
}
// 以上方法属于间接调用，
// 下面是直接调用
import com.java1234_3.pro20.Inner;
public class pro21 {
	public static void main(String[] args) {
		// 在调用内部类前，需要将外部类初始化
		pro20 test1=new pro20();
		// 在使用内部类时候，语法如下
        // 外部类名.内部类名   初始化名=外部类初始化名.new  调用的内部类
		pro20.Inner test=test1.new Inner();
		//这里调用的是是内部类
		test.show();
	}

}

2.8 代码块

​ 代码块分为普通代码块，写在方法里，

​ 通用代码块，一般写在类里，

​ 静态代码，只执行一次，

2.9、string类

​ 1.实现方式两种

public static void main(String[] args) {
        // 实例化String的方式一
        String name1="张三";
        System.out.println("name1="+name1);
         
        // 实例化String的方式二
        String name2=new String("李四");
        System.out.println("name2="+name2);
    }

​ 2.“==”与“equals方法的区别

​

// 比较 == 与 equals 的区别
String name1="张三"  //直接赋值
String name2=new String("张三");  //通过new的方式赋值
String name3=name2; //传递引用
// ==比较的是引用 判断的结果看地址是否相同  
System.out.println("name1==name2:"+(name1==name2)); // False
System.out.println("name1==name3:"+(name1==name3)); // False
System.out.println("name2==name3:"+(name2==name3));// true

// equals比较的是具体内容  判断的结果看值是否相同
System.out.println("name1.equals(name2):"+(name1.equals(name2)));// true
System.out.println("name1.equals(name3:"+(name1.equals(name3)));// true
System.out.println("name2.equals(name3):"+(name2.equals(name3)));// true

图示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dUaJkusp-1655192536161)(D:\java1234\java1234笔记\java1234笔记截图\image-20220609164843133.png)]

沁颖呀
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
JAVA自学教程(完整版)
04-27
第1章 Java环境及配置 第2章 Java基本语法 第3章 类和接口 第4章 Java Applet 第5章 Java图形处理 第6章 Java用户界面技术 第7章 异常、事件和多线程机制 第8章 输入输出技术 第9章 Java数据库技术 第10章 Java安全技术 第11章 Java网络技术(一) 第12章 Java网络技术(二) 第13章 Servlet技术 第14章 Java读写XML技术
JAVA自学之路
孤独剑的架构师之路
03-26 7883
Normal07.8 磅02falsefalsefalseMicrosoftInternetExplorer4<objectclassid="clsid:38481807-CA0E-42D2-BF39-B33AF135CC4D" id=ieooui>
爆肝四万字，写给Java零基础小白的自学路线和进阶指南，收藏能省掉几万学费。
最新发布
2301_82242844的博客
04-22 991
spring 提供 ioc 技术，容器会帮你管理依赖的对象，从而不需要自己创建和管理依赖对象了，更轻松的实现了程序的解耦。spring 提供了事务支持，使得事务操作变的更加方便。spring 提供了面向切片编程，这样可以更方便的处理某一类的问题。更方便的框架集成，spring 可以很方便的集成其他框架，比如 MyBatis、hibernate 等。aop 是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
Java自学
m0_62461358的博客
01-13 149
- 文件命名规则 如果一个类使用 public class 和 class 声明的话是有区别的： · public class：文件名称必须与类名称保持一致； · class：文件名称可以与类名称不一致，执行的时候执行的是生成的*.class 文件； · 所以在一个*.java 的文件中，只能有一个 public class 声明，但是允许有多个 class 声明，在编译之后会生成各自类名对应的.class 文件。 print 其中 println 最后的两个字母“ln”表示输出之 后会加一个换行出来，如
自学JAVA
csdn1314hjb的博客
06-11 1254
自我介绍：我大学的专业是 计算机网络。能力的不足的我只能做一个小小的网管。 公司的环境：公司有一大群的JAVA工程师。我也想提升自己。所以有了后来的事情 准备开始： 每个周四，总部的IT经理都会来到我分管的分部来现场工作，他们维护着一个ERP。我也常常和他闲聊。不经历以的我就提到了我想学习JAVA的想法给他，果然，他也不装傻。直接抛了一句：自己完成一个独立后台开发的WEB项目，我就给机会...
java学习自学
Ambition_yugurt的博客
07-18 311
Java学习自学，不知道有多少人曾动过这个念想，作为IT圈的长青树，同时也是目前应用最广、最受开发者青睐的编程语言，Java成为了很多IT小白入行IT圈的首选。不过小白们都会遇到这样一个问题，java应该怎么学？那么接下来小编将为大家总结一下java自学的方法。 1、学习java应该具备的能力 若想要自学java，那么你至少应该具备3种能力：搜索知识能力、理性看待术语的能力、抽象思维和结构化思考的能力。在网上，人人都说java好学，但事实真的如此吗？Java虽然是编程语言中较为简单的一类，但并.
java自学手册
08-18
【Java自学手册】这篇资料主要面向想要通过自学进入IT行业的Java初学者，提供了一些建议和学习路径。首先，作者强调了选择学习方向的重要性，提醒读者不要盲目听信培训机构或文章的宣传，而是要自己观察市场的需求。...
java 基础篇.docx
10-22
在自学Java的过程中，了解其基础知识至关重要。以下是对文档中提到的知识点的详细说明： 1. **数据类型**：Java有八种基本数据类型，包括四种整型（int、short、long、byte）、两种浮点型（float、double）、char...
java自学路线图(超全超详细)
11-21
Java自学路线图 Java 是一门广泛应用的编程语言，掌握 Java 语言需要扎实的基础知识和系统的学习路径。本文将为您提供一份 Java 自学路线图，涵盖 Java 基础篇、数据库学习和框架大部分三个主要部分，旨在帮助您...
Java自学+Java变量+新手小白
03-25
本篇文章主要是讲的Java变量的知识点
Java 提高篇 v1.1.pdf
03-16
本文是作者成功自学 java 后总结出的，一整套知识点集合。适用正在自学 java 或准备自学的人群
JAVA自学教程(史上最全).
09-01
全面讲解java的学习内容，全部1000页，基本概述所有学习内容。
java自学资料
04-03
问题目录： -----------初级----------------- 1：基本数据类型相互转换： 2：有关Switch的一些知识 3：服务器与客户端通信： 4：java.util.Date与java.sql.Date的运用 5：泛型学习 6：SQL预编译 7:i++和++i的区别 8:判断输入文本是否全是半角空格js 9:java中金额的精确计算问题 10:有关继承的要点 11:有关继承的问题 12;有关static、final的基本规则 13:有关数组的知识点 14:数组的拷贝 15:数组中插入法实现排序 16：Object类 1)、equals与==的区别 17：如何判断信息中有没有中文： --------------中级-------------- 18:有关Collection 的新增、修改、删除 19:List、Collection的区别 20：map集合分析：
JAVA自学--基础篇
James0703的博客
06-01 618
       java已经学习了一个月了，本人目标是打算三个月自学安卓开发，不过还好能有6年经验的资深人士带领，平常的时候大多数还是自己找资料和视频学，遇到一些实在搞不懂的东西才会去请教，下面分享一些自己学习的心路历程。       我的java学习视频是在阿里云大学里边找到的，内容还比较全，分了基础篇、面向对象篇、高级开发篇，今天先分享一下基础篇的相关内容。一、java简介       Java...
Java基础自学
qq_53509808的博客
09-19 666
java零基础自学成才
如何自学JAVA
jrrexliang01的博客
12-20 1038
如何自学JAVA
深入浅出mybatis系列
10-28
深入浅出mybatis系列 适合自学、初学者使用

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沁颖呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值