Java:Java快速入门

Java入门必备知识 目录 一、前言 二、HelloWord案例编写 三、基础语法 1.快速生成语句: 2.注释: 3.标识符 标识符: 标识符的组成: 标识符的组成规则: 4.标识符命名约定: 小驼峰命名法: 命名规则: 5.变量 变量的注意事项: 6.常量 常量的概述: 常量的种类: 7.关键字 关键字的描述: 关键字的特点: 8.java数据类型 9.类型转化 自动类型转化: 自动类型转化的原因: 强制类型转化: 一、前言 前面已经进行... 阅读详情

源代码组织方式

Java程序由package+class组成,package对应目录的相对路径。


 
1 package com.happyframework.javastudy.hello; 2  3 public final class Hello { 4 public static void hello(){ 5 System.out.println("hello!"); 6 } 7 } 

关于class有如下几点规则:

  1. 文件的名字必须和class的名字一致(public级别的class名字)。
  2. 文件必须只包含一个public访问基本的class(可以包含多个非public级别的class)。
  3. package名字必须和目录一致。

入口方法

App.java


 
1 public class App { 2 public static void main(String[] args) { 3 com.happyframework.javastudy.hello.Hello.hello(); 4 } 5 } 

最终的项目结构

 

数据类型

8种原子类型

  1. 整数类型:byte、short、int和long。
  2. 小数类型:float和double。
  3. 字符类型:char。
  4. 布尔类型:bool。

除此之外的是interface、class和array。

小数类型的常量默认是double类型,声明float类型的常量需要使用F作为后缀。


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 float age = 28.0F; 8 System.out.println(age); 9 } 10 11 } 

运算符

  1. 算术运算符:+、-、*、/ 和 %,两个整数相除,结果还是整数。
  2. 赋值运算符:=、+=、-=、*=、/=、%=、&=、|=、~=、^=、<<=、>>= 、 >>>=、++ 和 --。
  3. 比较运算符:==、!=、<、<=、> 和 >=。
  4. 逻辑运算符:&&、|| 和 !。
  5. 位运算符:&、|、~、^、<<、>> 和 >>>。

字符串

String是拥有“值语义”的引用类型,字符串常量实现了“享元模式”,equals会按照内容进行比较,==按照地址比较。


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 String x = "段光伟"; 8 String y = new String("段光伟"); 9 10 System.out.println(x.equals(y)); // true 11 System.out.println(x == y); // false 12 } 13 14 } 

为了高效的修改字符串Java引入了StringBuffer。


 
1 { 2 StringBuffer sb = 3 new StringBuffer() 4 .append("段") 5 .append("光") 6 .append("伟"); 7  8 System.out.println(sb.toString()); 9 } 

数组

声明语法

DataType[] name 或 DataType name[]。

初始化语法

DataType[] name = new DataType[length]。

DataType[] name = new DataType[] { element1, element2, ...elementn }。

DataType[] name = { element1, element2, ...elementn }。


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 { 8 String[] strs = { "段", "光", "伟" }; 9 10 for (String item : strs) { 11 System.out.print(item); 12 } 13 } 14 } 15 16 } 

多维数组

只有不等长多维数组DataType[][],没有DataType[xxx, xxx]。

控制结构

  1. 条件:if-else if-else、switch-case-default和三元运算符(?:)。
  2. 循环:while、do-while、for和foreach。
  3. Labeled block。

 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 task: { 8 int age = 25; 9 10 System.out.println("start"); 11 12 if (age < 30) { 13 break task; 14 } 15 16 System.out.println("end"); 17 } 18 } 19 } 

最近觉得label是个不错的东西,最起码多了一种选择。

方法

Java中所有的赋值和方法调用都是“按值“处理的,引用类型的值是对象的地址,原始类型的值是其自身。

Java支持变长方法参数。


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 print("段光伟", "段光宇"); 8 print(new String[] { "段光伟", "段光宇" }); 9 } 10 11 private static void print(String... args) { 12 for (String item : args) { 13 System.out.println(item); 14 } 15 } 16 } 

类


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 Point point = new Point(100); 8 9 System.out.print(point); 10 } 11 } 12 13 class Point { 14 private int x = 0; 15 private int y = 0; 16 17 public Point(int x, int y) { 18 this.x = x; 19 this.y = y; 20 } 21 22 public Point(int x) { 23 this(x, x); 24 } 25 26 public String toString() { 27 return "(x:" + this.x + ",y:" + this.y + ")"; 28 } 29 } 

注意:调用自身的构造方法是用this(xxx,xxx,...)来完成,且必须位于第一行。

静态成员

Java中类似静态构造方法的结构,称之为:静态初始化代码块,与之对应的是实例初始化代码块,见下例:


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 System.out.println(Point.getValue()); 8 System.out.println(new Point()); 9 } 10 } 11 12 class Point { 13 private static int value = 0; 14 15 public static int getValue() { 16 return value; 17 } 18 19 static { 20 value++; 21 } 22 23 static { 24 value++; 25 } 26 27 private int x = 0; 28 private int y = 0; 29 30 { 31 this.x = 10; 32 } 33 34 { 35 this.y = 10; 36 } 37 38 public String toString() { 39 return "(x:" + this.x + ",y:" + this.y + ")"; 40 } 41 } 

继承

继承使用 extends,抽象类和抽象方法使用abstract声明,向下转型使用 (ChildType)instance,判断是否是某个类型使用 instanceof,见下例:


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 printAnimal(new Animal()); 8 printAnimal(new Dog()); 9 } 10 11 private static void printAnimal(Animal animal) { 12 if(animal instanceof Dog){ 13 System.out.println("I am a " + (Dog) animal); 14 } 15 else 16 { 17 System.out.println("I am an " + animal); 18 } 19 } 20 } 21 22 class Animal { 23 public String toString() { 24 return "Animal"; 25 } 26 } 27 28 class Dog extends Animal { 29 public String toString() { 30 return "Dog"; 31 } 32 } 

重写

Java中的重写规则比较灵活,具体如下:

  1. 除了 private 修饰之外的所有实例方法都可以重写,不需要显式的声明。
  2. 重写的方法为了显式的表达重写这一概念,使用 @Override进行注解。
  3. 重写的方法可以修改访问修饰符和返回类型,只要和父类的方法兼容(访问级别更高,返回类型更具体)。
  4. 可以使用final将某个方法标记为不可重写。
  5. 在构造方法中使用 super(xxx, xxx)调用父类构造方法,在常规实例方法中使用 super.method(xxx, xxx)调用父类方法。
  6. Java不支持覆盖(new)。

 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 Animal animal = new Animal(); 8 Animal dog = new Dog(); 9 10 animal.say(); 11 dog.say(); 12 13 animal.eat(animal); 14 dog.eat(dog); 15 16 System.out.println(animal.info()); 17 System.out.println(dog.info()); 18 } 19 } 20 21 class Animal { 22 private String name = "Animal"; 23 24 protected void say() { 25 System.out.println("Animal" + " " + this.name); 26 } 27 28 public void eat(Animal food) { 29 System.out.println("Animal eat " + food); 30 } 31 32 public Object info() { 33 return "Animal"; 34 } 35 36 @Override 37 public String toString() { 38 return "Animal"; 39 } 40 } 41 42 class Dog extends Animal { 43 private String name = "Dog"; 44 45 @Override 46 public final void say() { 47 System.out.println("Dog" + " " + this.name); 48 } 49 50 @Override 51 public final void eat(Animal food) { 52 super.eat(food); 53 54 System.out.println("Dog eated"); 55 } 56 57 @Override 58 public final String info() { 59 return "Dog"; 60 } 61 62 @Override 63 public final String toString() { 64 return "Dog"; 65 } 66 } 

包

包的名字和项目路径下的目录路径相对应,比如:项目路径为:C:\Study,有一个Java源文件位于:C:\Study\com\happyframework\study\App.java,那么App.java的包名字必须为:com.happyframework.study,且 App.java 的第一行语句必须为:package com.happyframework.study。

Java支持三种导入语法:

  1. 导入类型:import xxx.xxx.xxxClass。
  2. 导入包:import xxx.xxx.xxx.*。
  3. 导入静态成员:import static xxx.xxx.*。

 
1 import static util.Helper.*; 2 3 public class Program { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 puts("段光伟"); 10 } 11 } 

访问级别

Java支持四种访问级别:public、private、protected 和 default(默认),类型和接口只能使用public 和 default,成员和嵌套类型可以使用所有,下面简单的解释一下 protected 和 default。

  • protected 修饰过的成员只能被自己、子类和同一个包里的(不包括子包)其他类型访问。
  • default 修改过的类型或成员只能被自己和同一个包里的(不包括子包)其他类型访问。

嵌套类

Java支持如下几种嵌套类:

  1. nested class,定义在类型内部的类型。
  2. static nested class,使用 static 声明的 nested class,static nested class 可以访问所有外部类的静态成员。
  3. inner class,没有使用 static 声明的 nested class,inner class 可以访问所有外部类的实例成员,inner class 不能定义静态成员。

代码示例


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 OuterClass outer = new OuterClass(); 8 OuterClass.InnerClass inner = outer.new InnerClass(); 9 OuterClass.InnerClass.InnerInnerClass innerInner = inner.new InnerInnerClass(); 10 outer.show(); 11 inner.show(); 12 innerInner.show(); 13 14 OuterClass.StaticNestedClass staticNested=new OuterClass.StaticNestedClass(); 15 OuterClass.StaticNestedClass.StaticNestedNestedClass staticNestedNested=new OuterClass.StaticNestedClass.StaticNestedNestedClass(); 16 17 staticNested.show(); 18 staticNestedNested.show(); 19 } 20 } 21 22 class OuterClass { 23 int x = 1; 24 static int i = 1; 25 26 void show() { 27 System.out.println(x); 28 System.out.println(i); 29 } 30 31 class InnerClass { 32 int y = 2; 33 34 void show() { 35 System.out.println(x); 36 System.out.println(y); 37 } 38 39 class InnerInnerClass { 40 int z = 3; 41 42 void show() { 43 System.out.println(OuterClass.this.x); 44 System.out.println(y); 45 System.out.println(z); 46 } 47 } 48 } 49 50 static class StaticNestedClass { 51 static int j = 2; 52 53 void show() { 54 System.out.println(i); 55 System.out.println(j); 56 } 57 58 static class StaticNestedNestedClass { 59 static int k = 3; 60 61 void show() { 62 System.out.println(i); 63 System.out.println(j); 64 System.out.println(k); 65 } 66 } 67 } 68 } 

特殊的inner class:local class


 
1 public class LocalClassExample { 2 3 static String staticValue = "static value"; 4 String instanceValue = "instance value"; 5 6 public void test() { 7 8 final String finalLocalValue = "final local value"; 9 10 class LocalClass { 11 void test() { 12 System.out.println(staticValue); 13 System.out.println(instanceValue); 14 System.out.println(finalLocalValue); 15 } 16 } 17 18 LocalClass local = new LocalClass(); 19 local.test(); 20 } 21 } 

除了inner class的规则之外,local class可以访问局部final变量,在Java8中有更多的改进。

特殊的local class:anonymous class


 
1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 execute(new Action() { 8 @Override 9 public void execute() { 10 System.out.println("执行业务逻辑"); 11 } 12 }); 13 } 14 15 static void execute(Action action) { 16 System.out.println("事物开始"); 17 action.execute(); 18 System.out.println("事物结束"); 19 } 20 } 21 22 interface Action { 23 void execute(); 24 } 

常量

不废话了,直接看代码:


 
1 public final class Program { 2 static final String STATIC_CONSTANTS = "STATIC_CONSTANTS"; 3 final String INSTANCE_CONSTANTS = "INSTANCE_CONSTANTS"; 4 5 public static void main(String[] args) { 6 final String LOCAL_CONSTANTS = "LOCAL_CONSTANTS"; 7 8 System.out.println(STATIC_CONSTANTS); 9 System.out.println(new Program().INSTANCE_CONSTANTS); 10 System.out.println(LOCAL_CONSTANTS); 11 new Program().test("PARAMETER_CONSTANTS"); 12 } 13 14 public final void test(final String msg) { 15 System.out.println(msg); 16 } 17 } 

有一点需要注意的是:只有一种情况Java的常量是编译时常量(编译器会帮你替换),其它情况都是运行时常量,这种情况是:静态类型常量且常量的值可以编译时确定。

接口

Java的接口可以包含方法签名、常量和嵌套类,见下例:


 
1 public final class Program { 2 public static void main(String[] args) { 3 Playable.EMPTY.play(); 4 5 new Dog().play(); 6 } 7 } 8 9 interface Playable { 10 Playable EMPTY = new EmptyPlayable(); 11 12 void play(); 13 14 class EmptyPlayable implements Playable { 15 16 @Override 17 public void play() { 18 System.out.println("无所事事"); 19 } 20 21 } 22 } 23 24 class Dog implements Playable { 25 26 @Override 27 public void play() { 28 System.out.println("啃骨头"); 29 } 30 31 } 

枚举

Java枚举是class,继承自java.lang.Enum,枚举中可以定义任何类型可以定义的内容,构造方法只能是private或package private,枚举成员会被编译器动态翻译为枚举实例常量,见下例:


 
1 public final class Program { 2 public static void main(String[] args) { 3 System.out.println(State.ON); 4 System.out.println(State.OFF); 5 6 for (State item : State.values()) { 7 System.out.println(item); 8 System.out.println(State.valueOf(item.name())); 9 } 10 } 11 } 12 13 enum State { 14 ON(1), OFF(0); 15 16 int value = 1; 17 18 State(int value) { 19 this.value = value; 20 } 21 } 

调用枚举的构造方法格式是:常量名字(xxx, xxx),如果构造方法没有参数只需要:常量名子,如:


 
1 enum State { 2 ON, OFF 3 } 

异常

Java中的异常分为checked和unchecked,checked异常必须声明在方法中或被捕获,这点我觉得比较好,必定:异常也是API的一部分,见下例:


 
1 public final class Program { 2 public static void main(String[] args) { 3 try { 4 test(); 5 } catch (Exception e) { 6 System.out.println(e.getMessage()); 7 } 8 } 9 10 public static void test() throws Exception { 11 throw new Exception("I am wrong!"); 12 } 13 } 

所有继承Exception的异常(除了RuntimeException和它的后代之外)都是checked异常。

装箱和拆箱

Java提供了原始类型对应的引用类型,在1.5之后的版本还提供了自动装箱和自动拆箱,结合最新版本的泛型,几乎可以忽略这块。


 
1 import java.util.*; 2 3 public final class Program { 4 public static void main(String[] args) { 5 ArrayList list = new ArrayList(); 6 7 list.add(1); 8 int item1 = (Integer) list.get(0); 9 10 System.out.println(item1); 11 } 12 } 

注意:自动装箱和自动拆箱是Java提供的语法糖。

泛型

Java的泛型是编译器提供的语法糖,官方称之为:类型参数搽除,先看一下语法,然后总结一点规律:

泛型方法

测试代码


 
1 static <T> void puts(T msg) { 2 println(msg); 3 } 4 5 static void println(Object msg) { 6 System.out.println("Object:" + msg); 7 } 8 9 static void println(String msg) { 10 System.out.println("String:" + msg); 11 } 

调用泛型方法


 
1 System.out.println("generic method test"); 2 puts("hello"); 3 Program.<String> puts("hello"); 

输出的结果是


 
1 generic method test 2 Object:hello 3 Object:hello 

泛型类

测试代码


 
1 class TestGenericClass<T> { 2 T value; 3  4 void setValue(T value) { 5 this.value = value; 6 } 7 } 

调用代码


 
1 System.out.println("generic class test"); 2 System.out.println(t.value); 

输出结果


 
1 generic class test 2 1 

泛型接口

测试代码


 
1 interface TestInterface<T> { 2 void test(T item); 3 } 4 5 class TestInterfaceImp1 implements TestInterface<String> { 6 7 @Override 8 public void test(String item) { 9 System.out.println(item); 10 } 11 } 12 13 class TestInterfaceImp2<T> implements TestInterface<T> { 14 15 @Override 16 public void test(T item) { 17 System.out.println(item); 18 } 19 } 

调用代码


 
1 System.out.println("generic interface test"); 2 TestInterface<String> testInterface1 = new TestInterfaceImp1(); 3 testInterface1.test("hi"); 4 for (Method item : testInterface1.getClass().getMethods()) { 5 if (item.getName() == "test") { 6 System.out.println(item.getParameterTypes()[0].getName()); 7 } 8 } 9 10 TestInterface<String> testInterface2 = new TestInterfaceImp2<>(); 11 testInterface2.test("hi"); 12 for (Method item : testInterface2.getClass().getMethods()) { 13 if (item.getName() == "test") { 14 System.out.println(item.getParameterTypes()[0].getName()); 15 } 16 } 

输出结果


 
1 generic interface test 2 hi 3 java.lang.String 4 java.lang.Object 5 hi 6 java.lang.Object 

类型参数约束

测试代码


 
1 class Animal { 2 } 3 4 class Dog extends Animal { 5 } 6 7 class Base<T extends Animal> { 8 public void test(T item) { 9 System.out.println("Base:" + item); 10 } 11 } 12 13 class Child extends Base<Dog> { 14 15 @Override 16 public void test(Dog item) { 17 System.out.println("Child:" + item); 18 } 19 } 

调用代码


 
1 System.out.println("bounded type parameters test"); 2 Base<Dog> base = new Child(); 3 base.test(new Dog()); 4 for (Method item : base.getClass().getMethods()) { 5 if (item.getName() == "test") { 6 System.out.println(item.getParameterTypes()[0].getName()); 7 } 8 } 

输出结果


 
1 bounded type parameters test 2 Child:Dog@533c2ac3 3 Dog 4 Animal 

类型搽除过程

  1. 将泛型定义中的类型参数去掉。

 
class Base { public void test(T item) { System.out.println("Base:" + item); } } 
  1. 将T换成extends指定的约束类型,默认是Object。

 
1 class Base { 2 public void test(Animal item) { 3 System.out.println("Base:" + item); 4 } 5 } 
  1. 如果有非泛型类型继承或实现了泛型基类或接口,而且进行了重写,根据情况,编译器会自动生成一些方法。

 
1 class Child extends Base { 2 @Override 3 public void test(Animal item) { 4 this.test((Dog)item); 5 } 6 7 public void test(Dog item) { 8 System.out.println("Child:" + item); 9 } 10 } 
  1. 根据泛型参数的实际参数搽除调用代码。

 
1 System.out.println("bounded type parameters test"); 2 Base base = new Child(); 3 base.test(new Dog()); 4 for (Method item : base.getClass().getMethods()) { 5 if (item.getName() == "test") { 6 System.out.println(item.getParameterTypes()[0].getName()); 7 } 8 } 

这里说的不一定正确,特别是Java泛型的约束支持&(如:可以约束实行多个接口),不过过程估计差别不大,我没有看Java语言规范,这里只是大概的猜测。

”我自己是一名从事了十余年的后端的老程序员,辞职后目前在做讲师,近期我花了一个月整理了一份最适合2018年学习的JAVA干货(里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码,MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料)从事后端的小伙伴们都可以来了解一下的,这里是程序员秘密聚集地,各位还在架构师的道路上挣扎的小伙伴们速来。“
加QQ群:611481448(名额有限哦!)

java入门看这一篇就够了 / 定义一个学生类// 1. 属性(字段) - 封装数据// private修饰符实现封装,外部不能直接访问// 2. 构造方法 - 创建对象时初始化// 构造方法名与类名相同,没有返回类型// this关键字引用当前对象// 3. 默认构造方法(无参构造方法)// 如果没有显式定义构造方法,Java会提供默认的无参构造方法// 如果定义了有参构造方法,建议同时定义无参构造方法this.name = "未知";// 4. 实例方法 - 对象的行为。 阅读详情

相关推荐

java零基础从入门到精通(全)

目录前言1. 入门知识1.1 java体系1.2 JDK/JRE/JVM区别1.3 编译与运行理解1.4 类体函数细节2. 标识符 前言 java优势 健壮性(JVM(C++语言写的一个虚拟的计算机)、GC(垃圾回收机制)) 多线程并发 可移植性/跨平台 1. 入门知识 1.1 java体系 JavaSE:标准版 JavaEE:企业版 JavaME:微型版 1.2 JDK/JRE/JVM区别 JVM是不能独立安装的。 JRE和JDK都是可以独立安装的 层层嵌套,jvm包括jdk,jdk包括jre

码农研究僧的博客 6万+

java编程基础(入门级)(超级完整版)

java基础编程 01基础知识 1.计算机基础 【1】进制 A.十进制转化二进制 除以2,求余数,商继续除以2,一直到0为止,从底下往上得到结果。 B.二进制转化十进制 1 | 1 | 0 | 0 23∣22∣21∣202^3 | 2^2 | 2^1 | 2^023∣22∣21∣20 8+4+0+0=128+4+0+0=128+4+0+0=12 【2】 计算机的储存方式 位(bit):0或1 字节(byte):8位1字节,数据储存的最小单位 1 KB=1024 Byte 1 MB=1024 KB 1 GB=

weixin_41406651的博客 6万+

Spring Boot在Java领域的快速入门指南

本指南的主要目的是帮助Java开发者快速掌握Spring Boot的基本概念、开发流程和应用技巧。我们将涵盖Spring Boot的核心功能,包括依赖管理、自动配置、嵌入式服务器等。通过本指南,读者将能够使用Spring Boot开发简单的Web应用程序,并了解如何在实际项目中应用Spring Boot。核心概念与联系:介绍Spring Boot的核心概念和架构。核心算法原理 & 具体操作步骤:讲解Spring Boot的核心算法原理,并给出具体的操作步骤。

Java大师兄的博客 1186

Java 入门 (超级详细)

Java是一种高级编程语言,由Sun Microsystems公司于1995年推出。Java具有跨平台性、面向对象、健壮性、安全性、可移植性等特点,被广泛应用于企业级应用开发、移动应用开发、大数据处理、云计算等领域。Java程序可以在不同的操作系统上运行,只需编译一次,就可以在任何支持Java虚拟机(JVM)的平台上运行。Java还提供了丰富的库和框架,可以加快开发过程,提高开发效率。变量是计算机程序中用于存储数据的一种数据类型。它是一个名称,代表了一个值或一个对象,可以在程序中多次使用。

qq_63519395的博客 10万+

Jetson nano/nx使用麒麟arm版向日葵实现远程控制

Jetson nano/nx使用麒麟arm版向日葵实现远程控制1、安装向日葵软件2、运行Sunlogin Client3、向日葵闪退问题4、重启系统5、重启后黑屏问题 特别提醒: 本博客的第3步切换桌面管理环境到lightdm,存在重启后开机黑屏的风险,我在自己的nano/nx上都没有问题,但帮一个同学的nx配置时,切换到lightdm,重启开机却出现了黑屏,所以执行第3步的话要有心理准备,黑屏解决方法见第5步,特此提醒。

胡乱学点东西 2万+

基于电子海图的水面无人艇全局路径规划

Research and Implementation of Global Path Planning for Unmanned Surface Vehicle Based on Electronic Chart (基于电子海图的水面无人艇全局路径规划)   该论文已经在ICMIR2017会议上发表,附上springer的文献地址 Research and Implementation of Gl...

weixin_30797199的博客 1591

Java笔记——如何快速入门 Java?

这是一个基于 Spring Boot、MyBatis-Plus、MySQL、Redis、ElasticSearch、MongoDB、Docker、RabbitMQ 等技术栈实现的社区系统,采用主流的互联网技术架构、全新的UI设计、支持一键源码部署,拥有完整的文章&教程发布/搜索/评论/统计流程等,代码完全开源,没有任何二次封装,是一个非常适合二次开发/实战的现代化社区项目?对于新人来说,最重要的是掌握 Java 后端开发四大件,Java 基础、Spring Boot、MySQL、Redis。

a25847a的博客 1772

Ubuntu Server 22.04.5系统安装教程

该教程主要是演示在服务器上安装Ubuntu server 22.04系统的详细步骤,主要包含,安装系统前的准备(镜像的下载,启动盘的制作),安装系统时的语言选择,网络设置,切换镜像源(可根据实际需求来配置,本文使用清华镜像源),手动分区,用户设置,ssh服务安装等。以上就是关于Ubuntu Server 22.04系统安装的详细过程。

逆水行舟,不进则退。 7771

如何快速入门Java

遇到瓶颈时,可通过“拆解问题→分步实现”降低难度(如将“图书管理系统”拆分为“数据存储”“用户交互”“业务逻辑”模块)。- Java SE核心类:String、ArrayList、HashMap、File(文件操作)、IO流(读写文件)。- IDE安装:IntelliJ IDEA(主流)或Eclipse,学会创建项目、调试代码(打断点、查看变量)。- 核心目标:掌握Java语法规则、数据类型、运算符、流程控制(if/for/while)、数组等基础要素。

darling_798的博客 1260

信贷风控实战指南:Vintage分析表从数据建模到风险洞察

本文是一份信贷风控实战指南,详细阐述了Vintage分析从数据建模到风险洞察的全流程。文章深入解析了Vintage分析作为信贷资产“体检报告”的核心价值,并提供了从借据表与还款计划表设计、账龄计算、逾期口径判定到风险暴露计算与最终可视化透视的完整SQL实现方案,旨在帮助风控从业者构建精准的风险监控体系。

nft7creator的博客 321

基准电压 + 运放 + 低边MOS恒流源控制原理

因为恒流源强制 Iout不变,而 Vin​ 增加时,负载压降 Iout⋅Rload不变,多余的电压只能由MOS管的 VDS承担,因此 VDS必然增加。在饱和区,MOS 管的 ID 仅由 VGS决定,与 VDS 无关,这样,负载变化时,VDS可自由调整以维持 Iout恒定。当 Vin​ 小到无法满足 VDS>VGS−Vth时,MOS管进入线性区,Iout 会随 Vin​ 下降而减小,恒流失效。由于 Vref和 Rsense未变,Iout无需调整,运放无需动作,OUT保持不变,Iout恒定。

weixin_50643237的博客 2658

java快速入门

Java 集合框架主要由两大接口派生而出:Collection 和 Map。Collection 接口用于存储单个元素,而 Map 接口用于存储键值对。集合框架提供了统一的接口和方法,方便开发者对不同类型的集合进行操作,同时也提高了代码的可复用性和可维护性。

m0_74013450的博客 1424

【Kubernetes】Kubernetes 安全沙箱深度对比:gVisor vs Kata Containers

Kubernetes安全沙箱深度对比:gVisor和Kata Containers在架构、性能与安全性方面各有特点。gVisor通过用户态内核(Sentry)实现软件隔离,启动快(毫秒级)但CPU开销大(20-30%),适合Web服务等场景。Kata Containers采用轻量级虚拟机提供硬件级隔离,启动较慢(1-2秒)但兼容性更好,适合金融等高安全需求。测试显示gVisor在动态请求下性能下降33%,而Kata性能接近原生。建议根据场景选择:多租户/快速启动用gVisor,敏感数据/极致安全用Kata,

九师兄 179

RabbitMQ3:Java客户端快速入门

AMQP:Advanced Message Queuing Protocol(高级消息队列协议)。解读:首先AMQP是一种协议,类似于http这种,规定了应用程序之间传递消息的标准。该协议与语言、平台无关,因此可实现跨语言、跨平台。Spring AMQP:是基于AMQP协议,定义的一套API规范。提供了模板来发送和接收消息。Spring AMQP官方网址:此时是生产者直接将消息放入队列,都没经过交换机这一环节。可见此入门案例,是helloworld级别的。t=O83A。

casually的博客 1501

Oracle EBS Interface/API(49)- AP付款取消API

Oracle EBS AP付款取消API介绍和简单实例

陈显平的专栏-Oracle EBS 850

JavaScript高级程序设计

作者:禅与计算机程序设计艺术 1.简介 JavaScript(简称JS)是一种直截了当、简单易用的动态脚本语言。它最初由Netscape公司的Brendan Eich(布兰登·艾奇)于1995年创建,但后来逐渐成为事实上的通用编程语言。目前,JS已经成为世界上最流行的客户端脚本语言,广泛用于网页开发、移

AI天才研究院 2269

java快速入门_Java概念快速入门1

java快速入门 配置。 入门 要开始使用Java,必须下载并安装Sun的JDK(Java开发工具包)版本。 撰写本文时,最新版本是JDK 6,可从以下位置下载 http://java.sun.com/javase/downloads/index.jsp 。 我将使用JDK 5(更新8) 但在大多数情况下,它们也会提供在JDK 1.4编译器上也能使用的代码。 我还将在1.6编译...

IT与开发人员的地盘 152

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

java se 快速入门

Java是一种高级编程语言,由Sun Microsystems公司于1995年推出。Java具有跨平台性、面向对象、健壮性、安全性、可移植性等特点,被广泛应用于企业级应用开发、移动应用开发、大数据处理、云计算等领域。Java程序可以在不同的操作系统上运行,只需编译一次,就可以在任何支持Java虚拟机(JVM)的平台上运行。Java还提供了丰富的库和框架,可以加快开发过程,提高开发效率。java 体系java se:java基础-- 如果做java web方向开发和 安卓开发,这个必学。

go|Python的个人博客 2165

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

java怎样快速入门呢?

JAVA快速入门的方法:   一、掌握静态方法和属性     静态方法和属性用于描述某一类对象群体的特征,而不是单个对象的特征。Java中大量应用了静态方法和属性,这是一个通常的技巧。但是这种技巧在很多语言中不被频繁地使用。理解静态方法和属性对于理解类与对象的关系是十分有帮助的,在大量的Java规范中,静态方法和属性被频繁使用。因此学习者应该理解静态方法和属性。Java在方

m13286282的专栏 810

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Java如何快速入门?Java基础_Java入门

如何快速入门Java? 一、作为刚接触Java的新手,肯定要先了解Java的基础。 Java 基本语法、Java 平台应用、Java的核心概念:JVM、JDK、JRE以及Java面向对象思想,同时要会学到如何在系统中搭建Java开发环境,以及如何利用第三方工具进行Java程序的开发。 学习Java语言最重要的是:学习步骤和方法 只要找到适合自己的学习方式,找到适合自己现阶段的学习资料,学习的过程中最好记笔记,因为好记性不如烂笔头。还有就是要培养自己的学习兴趣,这样才能...

m0_46184557的博客 206

02、Java学习-快速入门:

全程为Java Development Kit,即Java开发工具包,JDK = JRE + java的开发工具【java,javac等】是提供给开发人员使用的,包含了java的开发工具,也包括了JRE。全程为Java Runtime Environment,Java运行环境;JRE = JVM + Java的核心类库【类】如果想要运行一个开发好的Java程序,安装JRE即可。将Java源文件通过编译器编译成JVM可以识别的字节码文件;

jiangxianfengge的博客 937

Java快速入门

快速入门Java

m0_52452411的博客 664

好程序员Java培训分享如何快速入门Java编程

好程序员Java培训分享如何快速入门Java编程,作为老牌编程语言,Java拥有广阔的市场应用,企业对Java人才的需求一直居高不下。有很多非专业、零基础的人想要学习Java却不知道怎么快速入门,接下来好程序员Java培训小编就给大家简单分析一下。   零基础如何快速入门Java编程呢?目前比较常见的方式有两种:自学和参加培训班。   自学Java编程的好处是时间自由、经济消耗低,但存在的主要问题...

qq_35970166的博客 430

Java应该如何学习?能不能快速入门?

先说能不能快速入门吧这个问题,我个人认为在快速入门的前提下是要掌握好知识,就是又快有高效,不是一味的追求速度 学习方式 · 1,看书 · 2,看视频 · 3,报培训班 · 4,单独找人带 根据学习方式来说,我推荐入门最好是看视频,视频是入门比较快的,如果在条件允许的情况下报培训班或者找人带当然是最好不过了。 Java应该如何学习? 学习方法很重要,最好是视频+书籍+练习题+实战。编程一件需要长期积累的技术活,要提升自己当然不能放松自己。先看学习路线,在看学习方法,书籍对于初学者来说,我不建议.

java9875的博客 186
上一篇: 深度解析:Java为什么能够长盛不衰?
下一篇: 一遍记住Java常用的八种排序算法与代码实现
java1856905
博客等级 码龄8年 100粉丝 249原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值