使用IDEA进行学习

IntelliJ IDEA使用学习 IntelliJ-IDEA使用学习 阅读详情

idea的常用快捷键

Alt+Enter 导入包 自动修正代码
Ctrl+Y 删除光标所在行
Ctrl+D 复制光标所在行
Ctrl+Alt+L 格式化代码
Ctrl+/ 单行注释,再按取消注释
Ctrl+Shift+/ 多行注释,再按取消注释

方法的三种调用格式

方法其实就是若干语句的功能集合。
方法好比是一个工厂。
蒙牛工厂 原料:奶牛、饲料、水
产出物:奶制品
钢铁工厂 原料:铁矿石、煤炭
产出物:钢铁建材

参数(原料):就是进去方法的数据。
返回值(产出物):就是从方法中的数据。

定义方法的完整格式:
修饰符 返回值类型 方法名称(参数类型 参数名称,…){
方法体
return 返回值;
}
修饰符:现阶段的固定写法,public static
返回值类型:也就是方法最终产生的数据结果是什么类型
方法名称:方法的名字,规则跟变量一样,小驼峰
参数类型:进入方法的数据是什么类型
参数名称:进入方法的数据对应的变量名称
ps:参数如果有多个,使用逗号隔开
方法体:方法需要做
方法体:方法需要做的事情,若干代码
return:两个作用,第一个是停止当前方法,第二将后面的返回值还给调用处
返回值:也就是方法执行后最终产生的数据结果
注意:return后面的返回值,必须和方法名称前面的“返回值类型”,保持对应。

定义一个两个int数字相加的方法。三要素:
返回值类型 int
方法名称:sum
参数列表:int a,int b
方法的三种调用格式。
1.单独调用:方法名称(参数);
2.打印调用:System.out.println(方法名称(参数));
3.赋值调用:数据类型 变量名称 =方法名称(参数);

注意:此前学习的方法,返回值类型固定写为void,这种方法只能使用单独调用,不能进行打印调用和赋值调用。

public class MethodDefine {
    public static void main(String[] args) {
        //单独调用
        sum(10, 20);
        System.out.println("==========");

//打印调用
        System.out.println(sum(10, 20));
        System.out.println("==========");

        //赋值调用
        int num=sum(20,20);
        System.out.println("变量的结果"+num);

    }

    public static int sum(int a, int b) {
//            System.out.println("方法执行了?");
        int result = a + b;
        return result;

    }
}

对比有参数和无参数

有参数:小括号当中有内容,当一个方法需要一些数据条件,才能完成任务的时候,就是有参数。
例如两个数字相加,必须知道两个数字各是多少,才能相加。

无参数:小括号当中留空,一个方法不需要任何数据条件,自己就能独立完成任务,就是无参数。
例如定义一个方法,打印固定10次HelloWorld。

public class MethodParam {
    public static void main(String[] args) {
method1(10,20);
System.out.println("==========");
method2();
    }
    //两个数字相乘,做乘法,必须知道两个数字各自是多少,否则无法进行计算。
    //有参数
    public static void method1(int a,int b){
        int result=a * b;
        System.out.println("结果是:"+result);
    }
    //打印输出固定10次文本字符串
    public static void method2(){
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello,World"+i);
        }
    }
}

对比有返回值和无返回值

题目要求:定义一个方法,用来【求出】两个数字之和。(你帮我算,算了把结果告诉我)
题目变形:定义一个方法,用来【打印】两个数字之和。(你来计算,算完之后你自己负责显示结果,不告诉我)

注意事项:
对于有返回值的方法,可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法,只能使用单独调用,不能使用打印调用或者赋值调用。

public class MethodReturn {
    public static void main(String[] args) {
//我是main方法,我来调用你
        //我调用你,你来帮我计算一下,算完之后,把结果告诉我的num变量。
        int num=getSum(10,20);
        System.out.println("返回值是:"+num);
        System.out.println("==========");
        printSum(100,200);
    }
    //我是一个方法,我负责两个数字相加。
    //我有返回值int,谁调用我,我就把计算结果告诉谁
    public static int getSum(int a, int b){
        int result=a + b;
        return result;
    }
    //我是一个方法,我负责两个数字相加
    //我没有返回值,我不会把结果告诉谁
    public static void printSum(int a,int b){
int result =a+b;
        System.out.println("结果是:"+result);
    }
}

方法练习题

1比较两个数字是否相同

题目要求:
定义一个方法,用来判断两个数字是否相同。

public class MethodSame {
    public static void main(String[] args) {
        System.out.println(isSame(10,20));//false
        System.out.println(isSame(20,20));//true
    }
    /*
    三要素:
    返回值类型:boolean
    方法名称:isSame
    参数列表:int a, int b
     */
    public static boolean isSame(int a,int b){
    /*boolean same;
    if (a==b){
        same=true;
    }else {
        same= false;
    }*/
       // boolean same = a == b ? true : false;
       //boolean same = a == b;
    //return same;
        return a == b;
    }
}

求出1-100的和值

题目要求:
定义一个方法,用来求出1-100之间所有数字的和值

public class MethodSum {
    public static void main(String[] args) {
System.out.println("结果是:"+getSum());
    }
    /*
    三要素:
    返回值:有返回值,计算结果是一个int数字
    方法名称:getSum
    参数列表:数据范围已经确定,是固定的,所以不需要告诉我任何条件,不需要参数
     */
    public static int getSum(){
        int sum =0;
        for (int i = 1; i <=100; i++) {
            sum += i;
        }
        return sum;
    }
}

打印指定次数的HelloWorld

题目要求:
定义一个方法,用来打印指定次数的HelloWorld

public class MethodPrint {
    public static void main(String[] args) {
printCount(10);
    }

    /*
    三要素:
    返回值类型:只是进行一大堆打印操作而已,没有计算,也没有结果要告诉调用出
    方法名称:printCount
    参数列表:到底要打印多少次?必须告诉我,否则我不知道,没办法打印。次数:int

     */
    public  static void printCount(int num){
        for (int i = 0; i < num; i++) {
            System.out.println("HelloWorld"+(i+1));
        }

    }
}

方法的注意事项

使用方法的时候,注意事项:
1,方法应该定义在类当中,但是不能在方法当中再定义方法,不能嵌套。
2.方法定义的前后顺序无所谓。
3.方法定义之后不会执行,如果希望执行,一定要调用:单独调用、打印调用、赋值调用。
4.如果方法有返回值,那么必须写上”return 返回值;“,不能没有。
5.return后面的返回值数据,必须和方法的返回值类型,对应起来。
6.对于一个void没有返回值的方法,不能写return后面的返回值,只能写return自己。
7.对于方法当中最后一行的return可以省略不写。
8.一个方法当中可以有多个return语句,但是必须保证同时只有一个会被执行到,两个return不能连写。

public class MethodNotice {
    public static int method1(){
        return  10;
    }
    public static void method2(){
       // return 10;//这是错误的写法!方法没有返回值,return后面就不能写返回值。
   return;//没有返回值,只是结束方法的执行而已。

    }
    public  static void method3(){
        System.out.println("AAA");
        System.out.println("BBB");
      //  return;//最后一行的return可以省略不写。
    }
    public static int getMax(int a,int b){
     /*   int max;
        if (a>b){
            max=a;
        }else {
            max=b;
        }
        return max;*/
        if (a>b){
            return a;
        }else {
            return b;
        }
    }
}

方法重载的基本使用

对于功能类似的方法来说,因为参数列表不一样,却需要记住那么多不同的方法名称,太麻烦。

方法的重载(Overload):多个方法的名称一样,但是参数列表不一样。
好处:只需要记住唯一一个方法名称,就可以实现类似的多个功能。

public class MethodOverload {
    public static void main(String[] args) {
       /* System.out.println(sumTow(10,20));//30
        System.out.println(sumThree(10,20,30));//60
        System.out.println(sumFour(10,20,30,40));//100*/
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
       // System.out.println(sum(10,20,30,40,50));//找不到任何方法来匹配,所以报错
    }
    public static int sum(int a, int b){
        System.out.println("有两个参数的方法执行!");
        return a+b;
    }
    public static  int sum(int a,int b,int c){
        System.out.println("有三个参数的方法执行!");
        return a+b+c;
    }
    public static  int sum(int a,int b,int c,int d){
        System.out.println("有四个参数的方法执行!");
        return a+b+c+d;
    }
}

方法重载的注意事项

方法重载与下列因数相关:
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同

方法重载与下列因素无关:
1.与参数的名称无关
2.与方法的返回值类型无关

public class MethodOverload {
    public static void main(String[] args) {
       /* System.out.println(sumTow(10,20));//30
        System.out.println(sumThree(10,20,30));//60
        System.out.println(sumFour(10,20,30,40));//100*/
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
       // System.out.println(sum(10,20,30,40,50));//找不到任何方法来匹配,所以报错
    }
    public  static  int sum(int a,double b){
return (int)(a+b);
    }
    public  static  int sum(double a,int b){
        return (int)(a+b);
    }
    public static int sum(int a, int b){
        System.out.println("有两个参数的方法执行!");
        return a+b;
    }
    //错误写法!与方法的返回值类型无关
   /* public static double sum(int a, int b){

        return a+b+0.0;
    }*/
    //错误写法!与参数的名称无关
    /*public static int sum(int x, int y){

        return x+y;
    }*/
    public static int sum(double a,double b){
        return (int)(a+b);
    }
    public static  int sum(int a,int b,int c){
        System.out.println("有三个参数的方法执行!");
        return a+b+c;
    }
    public static  int sum(int a,int b,int c,int d){
        System.out.println("有四个参数的方法执行!");
        return a+b+c+d;
    }
}

重载练习

1四种不同参数类型的方法

题目要求:
比较两个数据是否相等。
参数类型分别为两个byte类型,两个short类型,两个int类型,两个long类型,并在main方法中进行测试。

public class MethodOverloadSame {
    public static void main(String[] args) {
byte a=10;
byte b=20;
        System.out.println(isSame(a,b));
        System.out.println(isSame((short) 20,(short) 20));
        System.out.println(isSame(11,12));
        System.out.println(isSame(10L,20L));
    }
    public  static boolean isSame(byte a,byte b){
        System.out.println("两个byte参数的方法执行");
        boolean same;
        if (a==b){
            same=true;
        }else {
            same=false;
        }
        return same;
    }
        public  static boolean isSame(short a,short b){
            System.out.println("两个short参数的方法执行");
        boolean same = a ==b ? true : false;
        return same;

        }
        public static boolean isSame(int a,int b){
            System.out.println("两个int参数的方法执行");
        return a==b;
        }
        public static boolean isSame(long a,long b){
            System.out.println("两个long参数的方法执行");
        if (a==b){
            return  true;
        }else {
            return false;
        }
        }
    }

2判断方法的正确重载

1 public static void open(){}//正确重载
2 public static void open(int a){}//正确重载
3 static void open(int a, int b){}//代码错误:和第8行冲突
4 public static void open(double a, int b){}//正确重载
5 public static void open(int a, int b){}//代码错误:和第6行冲突
6 public void open(int i,double d){}//代码错误:和第5行冲突
7 public static void OPEN(){}//代码正确不会报错,但是并不是有效重载
8 public static void open(int i,int j){}代码错误:和第3行冲突

3实现重载的println方法

byte short int long float double char boolean
String
在调用输出语句的时候,println方法其实就是进行了多种数据类型的重载形式。

public class OverloadPrint {
    public static void main(String[] args) {
        myPrint(100);//int
        myPrint("Hello");
    }
    public static void myPrint(byte num){
        System.out.println(num);
    }
    public static void myPrint(short num){
        System.out.println(num);
    }
    public static void myPrint(int num){
        System.out.println(num);

    }
    public static void myPrint(long num){
        System.out.println(num);
    }
    public static void myPrint(float num){
        System.out.println(num);
    }
    public static void myPrint(double num){
        System.out.println(num);
    }
    public static void myPrint(char zifu){
        System.out.println(zifu);
    }
    public static void myPrint(boolean is){
        System.out.println(is);
    }
    public static void myPrint(String str){
        System.out.println(str);
    }
}

数组的概念

数组的概念:
是一种容器,可以同时存放多个数据值。
数组的特点:
1.数组是一种引用数据类型
2.数组当中的多个数据,类型必须统一
3.数组的长度在程序运行期间不可改变

数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。

两种常见的初始化方式
1.动态初始化(指定长度)
2.静态初始化(指定内容)

public class Array {
    public static void main(String[] args) {
        int score1=100;
        int score2=99;
        int score3=90;
        System.out.println(score3);//90
        score3=100;
        System.out.println(score3);//100
    }
}

数组的定义格式一:动态初始化

动态初始化数组的格式:
数据类型[ ] 数组名称 = new 数据类型[数组长度];

解析含义:
左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型
左侧的中括号:代表我是一个数组
左侧数组名称:给数组取一个名字
右侧的new:代表创建数组的动作
右侧数据类型:必须和左边的数据类型保持一致
右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字。

public class Array {
    public static void main(String[] args) {
      //创建一个数组,里面可以存放300个int数据
    // 格式:数据类型[] 数组名称 = new 数据类型[数组长度];
            int[] arrayA= new int[300];
            //创建一个数组,能存放10个double类型的数据
        double[] arrayB=new double[10];
        //创建一个数组,能存放5个字符串
        String[] arrayC=new String[5];
    }
}

数组的定义格式二:静态初始化

动态初始化(指定长度):在创建数组的时候,直接指定数组当中的数据元素个数。
静态初始化(指定内容):在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。
静态初始化基本格式:
数据类型[ ] 数组名称 =new 数据类型[ ] {元素1,元素2,…};
注意事项:
虽然静态初始化没有直接告诉长度,但是大括号里面的元素具体内容,也可以自动推算出来长度。

public class Array {
    public static void main(String[] args) {
        //直接创建一个数组,里面装的全是int数字,具体为:5、15、20
        int [] arrayA =new int[]{5,15,25};

        //创建一个数组,用来装字符串:”Hello“、”World“、”Java“
        String [] arrayB=new String[]{"Hello","World","Java"};
        
    }
}

数组的定义格式三:省略的静态初始化

使用静态初始化数组的时候,格式还可以省略一下。

标准格式:
数据类型[ ] 数组名称 =new 数据类型[ ] {元素1,元素2,…};

省略格式:
数据类型[ ] 数组名称 = {元素1,元素2,…};

注意事项:
1.静态初始化没有直接指定长度,但是仍然会自动推算得到长度。
2.静态初始化标准格式可以拆分成为两个步骤。
3.动态初始化也可以拆分成为两个步骤。
4.静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。

使用建议:
如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。

public class ArrayOne {
    public static void main(String[] args) {
//省略格式的静态初始化
        int[] arrayA={10,20,30};
        //静态初始化的标准格式,可以拆分成为两个步骤
        int[] arrayB;
        arrayB=new int[]{11,21,31};
        //动态初始化也可以拆分成为两个步骤。
        int[] arrayC;
        arrayC=new int[5];
    }
}

访问数组元素进行获取

直接打印数组名称,得到的是数组对应的:内存地址哈希值。
二进制:01
十进制:0123456789
十六进制:0123456789abcdef

访问数组元素的格式:数组名称[索引值]
索引值:就是一个int数字,代表数组当中元素的编号。
【注意】索引值从0开始,一直到”数组的长度-1“为止。

public class ArrayUse {
    public static void main(String[] args) {
       //静态初始化的省略格式
        int [] array={10,20,30};
//直接打印数组当中的元素
        System.out.println(array);//[I@723279cf
        System.out.println(array[0]);//10
        System.out.println(array[1]);//20
        System.out.println(array[2]);//30
//也可以将数组当中的某一个单个元素,赋值交给变量。
        int num =array[1];
        System.out.println(num);//20
    }
}

访问数组元素进行赋值

使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:
如果是整数类型,那么默认为0;
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为’\u0000’;
如果是布尔类型,那么默认为false;
如果是应用类型,那么默认为null。

注意事项:
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

public class ArrayUseTow {
    public static void main(String[] args) {
        //动态初始化一个数组
        int[] array=new int[3];
        System.out.println(array);//内存地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        System.out.println("===========");
        //将数据123赋值交给数组array当中的1号元素。
        array[1]= 123;
        System.out.println(array[0]);//0
        System.out.println(array[1]);//123
        System.out.println(array[2]);//0


    }
}

java中的内存划分

5个部分
1.栈(Stack):存放的都是方法中的局部变量。 方法的运行一定要在栈当中。
局部变量:方法的参数,或者是方法{ }内部的变量
作用域:一旦超出作用域,立刻从栈内存当中消失。
2.堆(Heap):凡是new出来的东西,都在堆当中。
堆内存里面的东西都有一个地址值:16进制
堆内存里面的数据,都有默认值。规则:
如果是整数类型,那么默认为0;
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为’\u0000’;
如果是布尔类型,那么默认为false;
如果是应用类型,那么默认为null。
3.方法区(Method Area):存储.class相关信息,包含方法的信息。
4.本地方法栈(Nativa Method Stack):与挫折系统相关。
5.寄存器(pc Register):与CPU相关。

一个数组的内存图

两个数组的内存图

两个引用指向同一个数组的内存图

常见问题 : 空指针异常

所有的引用类型变量,都可以赋值为一个NULL值。但是代表其中什么都没有。
数组必须进行new 初始化 才能使用其中的元素。
如果只是赋值了一个new,就没有进行new创建,
那么将会发生:
空指针异常 NullPointerException

原因:忘了new
解决:补上new

public class ArrayNull {

    public static void main(String[] args) {
        int [] array=null;
       //array =new int[3];
        System.out.println(array[0]);

    }
}

获取数组的长度

如何获取数组的长度,格式:
数组名称.length

这将会得到一个int数字,代表数组的长度。

数组一旦创建,程序运行期间,长度不可改变。

public class ArrayLength {
    public static void main(String[] args) {
        int [] arrayA =new int[3];
            int[] arrayB ={10,20,30,2,3,4,45,10};
            int len =arrayB.length;
        System.out.println("arrayB数组的长度是:"+len);
        System.out.println("=========");
        int []arrayC = new int[3];
        System.out.println(arrayC.length);//3
        arrayC =new int[5];
        System.out.println(arrayC.length);//5

    }
}

数组的遍历输出

遍历数组,说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出。

public class ArrayBl {
    public static void main(String[] args) {
        int[] array ={15,25,30,40,50};

        //首先使用原始方式
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
        System.out.println("===========");

        //使用循环,次数其实就是数组的长度
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }

    }
}

求出数组中的最值

最大值

public class ArrayMax {
    public static void main(String[] args) {
        
    
    int[] array={5,15,30,20,10000};

    int max =array[0];
        for (int i = 1; i < array.length; i++) {
            //如果当前元素,必max更大;则换
            if (array[i]>max){
                max=array[i];

            }
            
        }//谁最后最大,就能在max当中留下
        System.out.println("最大值"+max);
    }
}

最小值

public class ArrayMin {
    public static void main(String[] args) {
        
    
    int[] array={5,15,30,20,-20,10000};

    int min =array[0];
        for (int i = 1; i < array.length; i++) {
            //如果当前元素,必min更小;则换
            if (array[i]<min){
                min=array[i];

            }
            
        }//谁最后最大,就能在max当中留下
        System.out.println("最小值"+min);
    }
}

数组元素反转

数组元素的反转:
本来的样子:[1,2,3,4]
之后的样子:[4,3,2,1]

要求不能使用新数组,就用原来的唯一一个数组。

1.数组元素反转,其实就是【对称位置】的元素交换。

2.通常遍历数组用的是一个索引:
int i =0;
现在表示对称位置需要两个索引:
int min=0;
int max=array.length-1;

3.如何交换两个变量的值?
int a=10;
int b=20;
如果是两个水杯,都是满的,如何交换?借助第三个空杯子
int temp =a;
a=b;
b=temp;
用【第三个变量】倒手。

4.什么时候停止交换?
(1)min == max
(2)min>max
什么时候应该交换?
min<max

public class ArrayReverse {
    public static void main(String[] args) {
        int [] array ={10,20,8,7,11,89};
        //遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("========");
/*
初始化语句:int min=0,max=array.length-1
条件判断:min <max
步进表达式:min++,max--
循环体:用第三个变量倒手
 */
        for (int min=0,max=array.length-1;min <max;min++,max--){
            int temp=array[min];
            array[min]=array[max];
            array[max]=temp;

        }
//再次打印输出
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组作为方法参数——传递地址

数组可以作为方法的参数。
当调用方法的时候,向方法的小括号进行传参,传递进去的其实是数组的地址值

public class ArrayParam {
    public static void main(String[] args) {
        int[] array={10,20,30,40,50};
        System.out.println(array);//地址值
printArray(array);//传递进去的就是array当中保存的地址值
        System.out.println("aaa");
        printArray(array);
        System.out.println("bbb");

    }
    /*
    三要素
    返回值类型:只是进行打印而已,不需要计算,也没有结果,用void
    方法名称:printArray
    参数列表:必须给我数组,我才能打印其中的元素。 int[] array

     */



    public  static void printArray(int[] array){
        System.out.println("printArray方法收到的参数是:");
        System.out.println(array);//地址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

    }
}

数组作为方法返回值——返回地址

一个方法可以有0、1、多个参数;但是只能由0或者1个返回值,不能多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回,怎么办?
解决方案:使用一个数组作为返回值类型即可。

任何数据类型都能作为方法的参数类型,或者返回值类型。

数组作为方法的参数,传递进去的其实是数组的地址值。
数组作为方法的返回值,其实返回的也是数组的地址值。

public class ArrayReturn {
    public static void main(String[] args) {
int[] result=calculate(10,20,30);
        System.out.println("总和:"+result[0]);
        System.out.println("平均数:"+result[1]);
    }
    public static int[]  calculate( int a,int b,int c){
        int sum=a+b+c;//总和
        int avg=sum/3;//平均数
        //两个结果都希望进行返回
        //需要一个数组,数组可以保存多个结果
        /*int [] array=new int[2];
        array[0]=sum;
        array[1]=avg;*/
        int[] array={sum,avg};
        return array;
    }
}
IntelliJ IDEA学习总结(2)——IntelliJ IDEA 入门使用教程 由于 IntelliJ IDEA 官网在亚洲没有设服务器,且官网用到一些类似 Twitter、Facebook 等站的脚本会使得你在国内出现访问巨慢或是不允许访问的特殊情况,所以建议你在访问官网、访问插件库、小版本本地迭代更新等操作的时候出现奇怪问题的时候,请自备VPN等网络加速工具。很多用户都是先学习了 Eclipse、MyEclipse 再转到 IntelliJ IDEA 的,这里需要先说明的... 阅读详情

相关推荐

生物信息学新手必看:MAFFT多序列比对从安装到实战(附参数优化技巧)

本文为生物信息学新手提供了MAFFT多序列比对工具的完整指南。从Linux环境下的安装部署,到核心算法策略(如FFT-NS-i、L-INS-i)的选择逻辑,再到空位罚分等关键参数的深度解析与优化技巧,手把手教你完成从原始序列到高质量比对结果的实战流程,为后续进化树构建等分析奠定坚实基础。

weixin_29230773的博客 488

IDEA的学习

1.安装插件 首先点击File->Settings...->pulgins->输入XXXXX搜索->install重启idea 2.查找一个抽象类或接口的实现 快捷键 ctrl+alt+b 3.查看类之间的关系,形成关系图 找到类----》右键-----》Diagrams-----》show Diagrams 4.查看类内部的结构 ctrl +左键进入...

奇点 1141

A-Level经济例题解析及练习Opportunity Cost

例题Question: Opportunity CostYou are selling your 1996 Mustang.&nbsp; You have already spent $1000 on repairs.&nbsp;At the last minute, the transmission dies.&nbsp; You can pay $600 to have it repaired, or sell the car “as is.”In each of the fol

Alevel3的博客 747

IDEA最新使用教程和技巧保姆级总结(强迫症福音+新手必看)

本文主要整理与分享个人在使用IDEA做Java开发时做的各种配置,算是几年来的总结。File | Project Structure (或者快捷键:Ctrl + Alt + Shift + S) 另外可以对项目做jdk配置: File | Settings | Editor | File Encodings (或者快捷键:Ctrl + Alt + S)

一个任的博客 1万+

仿人型机械臂逆运动学避坑指南:当末端三关节平行时如何处理奇异点

本文深入探讨了6R仿人型机械臂在末三轴平行结构下的逆运动学求解策略,重点分析了运动学逆解中的奇异点问题及其处理方法。通过MATLAB实现展示了D-H参数建模、几何解析法求解流程以及奇异点规避策略,为工业机器人开发提供了实用的数值算法方案和工程优化技巧。

sss66的博客 886

Robot Arm 机械臂源码解析

由于我们用的是步进电机,运动的时候是一步一步的,并不是平滑的,这里假设在一个平面上面,一个x步进电机,一个y步进电机。那么放大它们所走的轨迹就会是阶梯状的。而它们也只能沿着网格运动。相当于有了一个最小的分辨率,这个分辨率就是一步。如下图所示,如果x,y电机同时走就能走出45度的斜线。在三维空间里面运动也是如此,你应该可以想象的出来;首先,是updateActualPosition,用来时时更新此时的差补位置,得到的是一个路径与时间t的函数(其中路径的范围为0,1,时间范围为0,dist/v)...

爱吃炸鸡的小猪's blog 1万+

2023最新版IntelliJ IDEA安装教程(非常详细)从零基础入门到精通,看完这一篇就够了

IDEA全称IntelliJ IDEA,是Java语言对的集成开发环境,IDEA在业界被认为是公认最好的Java开发工具。

Javachichi的博客 20万+

第八届传智杯WPS智能办公能力挑战赛练习题库

本文是关于WPS Office软件操作知识的选择题汇总,内容涵盖WPS文字、表格和演示三大组件的常用功能。主要包括:云文档协同编辑、文本框插入、幻灯片打印设置、数据排序与筛选、函数应用(如SUMIF、COUNT)、动画效果设置、格式刷使用、页眉页脚设置、单元格引用类型等基础操作要点。同时涉及计算机基础概念如二进制、ROM存储器等。题目以单选和多选形式呈现,附带详细答案解析,全面检验用户对WPS办公软件的功能掌握程度和实际操作能力,适用于办公软件技能培训和水平测试。

qq_73044452的博客 1439

史上最简单的 IntelliJ IDEA 教程

史上最简单的 IntelliJ IDEA 教程 原创 2017年03月10日 09:17:08 7004 15 17 1 简介   IntelliJ IDEA(简称 IDEA),是 Java 语言开发的集成环境,IDEA 在业界被公认为最好的 Java 开发工具之一,尤其在智能代码助手、代码自动提示、重构、J2EE 支持、各类

andyzhaojianhui的专栏 510

【YOLOv11改进- 主干网络】YOLOv11+RepViT: 从ViT的角度重新审视Mobile的CNN助力YOLOv11有效涨点;

本文给大家带来的改进内容是在YOLOv11中更换主干网络为RepViT,助力YOLOv11有效涨点,论文通过集成轻量级 ViT 的高效架构设计,逐步增强了标准轻量级 CNN(即 MobileNetV3)的移动友好性。这最终产生了一个新的纯轻量级 CNN 系列的主干网络。

qq_41304809的博客 791

VS2019项目使用CGAL6.1配置教程详细步骤

在VS2019项目中使用CGAL详细步骤

插件开发 334

IntelliJ IDEA 使用姿势学习

IntelliJ IDEA 使用姿势学习 工欲善其事,必先利其器。将一个IDE的高效用法学习掌握好,对开发效率带来的提升是显而易见的,且掌握得越早越好。废话不多说,赖次狗!(我也正在一边学习,所以这篇也当作笔记边学边写,平台是windows)。 首先,下面的命令我都会把它的英文名写出来,在实际的开发中,如果某个命令你忘了快捷键,可以点Help -> FindAction(快捷键ctrl + s

Funn Rose's Blog 2283

从微服务到 Agent 服务:架构思维的迁移

微服务的概念最早在2014年由Martin Fowler提出,核心是“将单体应用拆分为一组小的服务,每个服务运行在独立的进程中,服务之间采用轻量级的通信机制互相协作,每个服务围绕具体业务构建,并且可以独立部署到生产环境”。单一职责:每个微服务只负责一个业务领域的功能,比如订单服务只处理订单相关的逻辑,用户服务只处理用户相关的逻辑被动响应:微服务是“哑的”,只有收到外部请求的时候才会执行逻辑,本身没有主动决策的能力固定流程:微服务的逻辑是硬编码的,执行流程是提前定义好的,只能按照程序员写的代码处理请求。

AI智能探索者的博客 276

学习使用IntelliJ IDEA的第一天:安装IDEA

安装IDEA

weixin_45316900的博客 6392

老版QQ原生表情gif动态

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

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

学习使用intellij idea的使用问题总结

idea版本:2017.3.5版本 tomcat版本:tomcat7的32位 jdk版本:jdk1.8.0_141 目录 版本问题 配置tomcat问题 创建maven工程 创建maven父工程 创建service层和dao层 idea删除项目 idea导入eclipse项目导入方式 eclipse导入idea项目 idea导入eclipse项目 eclipse生成的项目...

qq_41758289的博客 548

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

尝试新版idea及免费学习使用

观望中我们可以看到idea的一些简介, 以及他的下载路径按钮。一直在用idea2018版,最近不知道是什么原因,经常会被卡掉,打开两个窗口,就会出现卡死状态。不知道是否是我的错觉,总感觉代码展现效果也没有以前那么生硬了,颜色标记略显缓和了!如果使用idea的话可以点击下方卡片,关注《coder练习生》,回复 idea。进入到这,如果系统安装过了idea,则提示你是否卸载原有版本。他提了30天的免费使用,对于我们学习使用可能会有些不够用。此方法,仅供学习使用,如果想要商&业使用则需要去官方授权!

ybb_ymm的专栏 673

【IntelliJ Idea】使用学习

【IntelliJ Idea】使用学习 转载:https://www.cnblogs.com/yangchongxing/p/10658259.html 目录 ==================================================== 1、Spring Boot 显示 RunDashboard 2、设置代码提示 Ctrl + 空格 3、设置文件过滤 4、...

weixin_30951231的博客 100

Java学习---使用IntelliJ IDEA 配置Maven

使用IntelliJ IDEA 配置Maven(入门) https://www.cnblogs.com/sigm/p/6035155.html 写的很详细,可用参考

紫色飞鱼儿的博客 239

学习笔记:Intellij Idea 使用

阅读背景:已知您有 Eclipse基础,是从 Eclipse 向 Intellij Idea 转变的。 文章目录1. Idea须知2. 更改设置3. 快捷键 (实际可以设置成 eclipse的)4. 设置5. Maven5.1 创建 Maven5.11 创建 Java Mavan5.12 创建 Maven Web5.2 打包 Maven5.21 打包 Java Maven5.22 打包 Maven...

Cg心 1425

IDEA学习使用心得

近期学习如何使用IDEA进行工作学习.发现IDEA真的强大 推荐链接https://www.bilibili.com/video/av30080993/?p=16 在此总结一下: 1.官网下载 2.安装 3.配置调节 4.关联数据库以及Git ...

皇棠 1175

IntelliJ IDEA 开发工具使用学习资料

使用IntelliJ IDEA 14和Maven创建java web项目 http://mark.leanote.com/post/%E4%BD%BF%E7%94%A8IntelliJ-IDEA-14%E5%92%8CMaven%E5%88%9B%E5%BB%BAjava-web%E9%A1%B9%E7%9B%AE

李威威的博客 5033

学习使用IntelliJ IDEA

一、定位代码   1、跳转:若干快捷键,可通过find action查询。   2、搜索 二、代码助手   1、列操作   2、live template 代码模板   3、postfix .模板 fori sout field return nn   4.alt enter快捷键 自动创建函数(create method) list r...

weixin_34259159的博客 133

IntelliJ IDEA 学习笔记 - 首次使用IntelliJ IDEA

本文记录首次打开IntelliJ IDEA的情况

codeke的博客 1170

IntelliJ Idea 使用技巧学习记录

下述内容均在公众号里面介绍,公众号持续更新中,如果喜欢可以订阅,么么哒 IntelliJIDEA之远程调试篇 IntelliJIDEA之草稿(Scratch) IntelliJIDEA之断点类型(Breakpoint) IntelliJIDEA之断点创建(CreateBreakpoint) IntelliJIDEA之多线程调试重点参数 Intelli...

niexianglin_csdn的博客 344

Intellij IDEA 使用学习

Intellij中名词解释: Project,就是一个完整的项目,类似Eclipse中的WorkSet(虽然WorkSet是人为归类的)。 Module,是Project中的模块,类似Eclipse中的Project。 Facet,据说Eclipse中也有,官方解释是代表了一个Module中使用的技术、框架和语言。它可以让Intellij知道怎么对待这些内容。 Artifa...

weixin_33898233的博客 127

intelliJ idea 学习使用 + 最全快捷键

结构 插件神器 free mybatis 从dao到xml的神器 Key promoter 快捷键提示 我没安装的 JRebel Plugin 热部署 GsonFormat 把 JSON 字符串直接实例化成类 其他 快捷键 Ctrl 快捷键 介绍 Ctrl + F 在当前文件进行文本查找 ...

zzqtty的博客 201
上一篇: java入门
下一篇: 面向对象
RYYYUUU
博客等级 码龄7年 12粉丝 19原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值