首页 / JAVA / JAVA基础语法和实战

JAVA基础语法和实战

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JAVA基础语法和实战，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含15812字，纯文字阅读大概需要23分钟。

内容图文

Java小节：

1.博客

大家都知道，博客很作用，生活的博主会在博客上记录自己的生活。旅游博主会记录自己的旅途等。而CSDN博客可以为我们提供完善的属于程序员的交流平台。咱们可以把我们所学的内容通过自己的理解写出来。这样既加深了印象，有可以锻炼写作表达能力。我就是从秦疆那学习Java开始写博客的。亦然，很多知识都可以从博客上去知道。大多数的程序员都在CSDN博客上发表自己的文章。所以和我一样学编程的小伙伴可以开始入坑CSDN博客了哦。

2.makerdowm语法

makerdowm语法在CSDN中也有官方的帮助文档。当然，我也自己总结了一下常用的编辑功能。在我的博客上的makerdown’如何使用。

3. 冯?诺依曼体系结构

计算机教父之称的冯?诺依曼提出的计算机体系结构。其结构是存储程序原理的理论。

4.注释

同样的，注释作为编程开发的一个工具方法，亦是很重要的。程序要精简易懂，没有注释的长程序，别人很难看懂，难以高效开发。

5.数据基本类型及引用类型（primitive type、reference type）

整数类型：byte short int char long
小数类型：float double
字符：char
字符串：String
布尔值：boolean （只有两个有效值true、false）
引用类型：类、接口、数组

6.类型转换

强制转换：高容量转到低容量

package com.f.www.base;

public class leixingzhuanhuan {
    public static void main(String[] args) {
        int i=128;
        byte i2= (byte) 128;
        System.out.println(i);
        System.out.println(i2);
        //强制转换（类型）变量名  高-低
        //自动转换 ，低-高
        /**1.不能对布尔值进行转换
         * 2.不能把对象转换成不相干的类型
         * 3。转换时可能存在内存溢出，或精度问题
         * 4.把高容量转换成低容量时，强制转换
         */
        System.out.println("-----------------------");
        System.out.println((int)23.5);
        System.out.println((int)-23.98f);//小数点后面舍去了 精度问题。
        System.out.println("------------------------");
        //溢出问题
        int money=10_0000_0000;
        int years =20;
        int total=money*years;
        long total2=money*years;
        int total3= (int) (money*((long)years));//转换之前默认时int类型，
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);
        System.out.println("---------------------------");
        long total4=(int)money*(long)years;//计算之前先转换一个变量类型
        System.out.println(total4);

    }
}

7.变量

局部变量：必须声明和初始化值
实例变量：从属于对象，如不初始化则引用其类型默认值
（基本类型默认值为0，布尔值为false，其余类型皆为null）
常量（constant）：初始化后不能改变其值

package com.f.www.base;

public class bl {
    //类变量，从属于类
    static double salaey=3000;
    //实例变量从属于对象，如不初始化,输出这个类型的默认值0，0.0；
    //布尔值的默认值是false
    //其他类型都是null
    String name;
    int age;
    final int A=1;//定义了一个常量名为A，值为1的常量（常量名一般用大写字母）
    public static void main(String[] args) {
        //局部变量,必须声明和初始化
        int i=10;
        System.out.println(i);
        bl bl=new bl();
        System.out.println(new bl().age);//new 类 类名（）.变量名
        System.out.println(new bl().name);
        System.out.println(bl.age);
        System.out.println(bl.name);

    }
}

8. 运算符

自增运算符++
自减运算符–
自增自减运算符在前：先运算再赋值。
自增自减运算符在后：先赋值再运算
幂运算：math工具
三元运算：x?y:z

package com.f.www.base.Operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算
        int a=10;
        int b=20;
        int c=30;
        int d=40;
        System.out.println(a+b);
        System.out.println(a-c);
        System.out.println(a*b);
        System.out.println(a/(double)c);
        System.out.println("-------------------------");
        long a1=123333;
        int a2=122;
        short a3=10;
        byte a4=1;
        System.out.println((double)a3+a4);
        System.out.println(a>b);
        System.out.println(d%a);//模运算
        System.out.println("-------------------------");
        int x1=3;
        System.out.println(x1);
        int x2=x1++;//先赋值再自增
        int x3=++x1;//先自增在赋值
       // System.out.println(x1);
        System.out.println(x2);
        System.out.println(x3);
        //幂运算
        double pow = Math.pow(2, 3);
        System.out.println(pow);
        //逻辑运算符
        boolean c1=true;
        boolean c2=false;
        System.out.println("c1&&c2："+(c1&&c2));//逻辑与预算:全为真，结果为真
        System.out.println("c1||c2:"+(c1||c2));//逻辑或预算：一个为真，结果为真
        System.out.println("!(c1||c2:)"+!(c1||c2));//如果是真，则为假，反之。
        System.out.println("--------------------------");
        //位运算
        /*
        A=0011 1100
        B=0000 1111
        -----------
        A&B=0000 1100
        A|B=0011 1111
        A^B=0011 0011
        ~A=1100 0011
         */
        System.out.println("---------------");
        System.out.println(2<<3);
        System.out.println("---------------");
        int d1=0x08;
        int d2=0x16;
        System.out.println(d1|d2);
        //短路运算
        System.out.println("---------------");
        int c3=5;
        int c5=c3++;
        boolean c4=(c3<17)&&(c3++<7);
        System.out.println("c4:"+c4);
        System.out.println("c5:"+c5);
        System.out.println("----------------");
        System.out.println(c3);
        /*
        int a=10;
        int b=20;
        int c=30;
        int d=40;
         */
        a+=b;//a=a+b
        System.out.println(a);
        a-=b;//a=a-b
        System.out.println(a);
        //三元运算符
        //x?y:z 如果x==true 则结果为y，否则为z
        int score =50;
        String type=score<60?"不及格":"及格";
        System.out.println(type);
    }
}

9.包机制

公司官网倒置建包。

10.顺序结构、if选择结构、swich结构、while、do while结构、for、for增强结构

package Struct;

import java.util.Scanner;

public class StructDemo01 {
    public static void main(String[] args) {
        System.out.println("Hello 1");
        System.out.println("Hello 2");
        System.out.println("Hello 3");
        System.out.println("Hello 4");
        System.out.println("Hello 5");
        //顺序结构
        System.out.println("----------------");
        Scanner scanner=new Scanner(System.in);
        String s=scanner.nextLine();
        if (s.equals("Hello")){
            //equals  比较字符串是否一致
            System.out.println(s);
        }
        System.out.println("End");
        //if单选泽结构
        System.out.println("--------------");
        int score=scanner.nextInt();
        //score  成绩
        if (score>60) {

            System.out.println("成绩合格" + score);
        }
        else {
            System.out.println("成绩不合格" + score);
        }
        // if双选结构
        System.out.println("------------------");
        int score1=scanner.nextInt();
        if(score1>=90) {
            System.out.println("优");
        }else if (score1>=60&&score1<90){
            System.out.println("良");
        }else if (score1>=30&&score1<60){
            System.out.println("中");
        }else if (score1>=0&&score1<30){
            System.out.println("差");
        }else System.out.println("成绩不合法");
        //单行if else 可不带大括号
        //if 多选择结构
        System.out.println("------------------");
        scanner.close();
    }
}

package Struct;

public class switchDemo01 {
    public static void main(String[] args) {
        String grade="a";
        switch (grade){
            case "a":
                System.out.println("还有诗和远方的田野");
                break;
            case"b":
                System.out.println("良好");
                break;
            case "c":
                System.out.println("及格");
                break;
            case "d":
                System.out.println("再接再厉");
                break;
            case "e":
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
                //case具有穿透性，所以用break截止，swich 匹配一个具体值
        }
    }
}

package Struct;

public class DoWhileDome01 {
    public static void main(String[] args) {
        int a=0;
        int sum=0;
       //while
        while(a<0){
            System.out.println(a);
        }
        //先执行判断是否为真再执行顺序操作
        //do while
        System.out.println("-----------");

        do {
            a++;
            sum=sum+a;
        }
        while (a<100);
        System.out.println(sum);
        //do while先执行一次do 再执行顺序判断。
    }
}

package Struct;

public class ForDemo01 {
    public static void main(String[] args) {
        int oddsum=0;
        int evensum=0;
        //计算100以内的奇数和与偶数和
        for (int i = 0; i < 100; i++) {//初始化条件  条件判断  迭代
            if (i%2!=0) {
                oddsum += i;//循环体
            }else
            {
                evensum+=i;//循环体
            }
        }
        System.out.println("奇数和："+oddsum);
        System.out.println("偶数和："+evensum);
        System.out.println("-----------------");
        //计算1000以内的可以被5整除的数，并每行输出3个。
        for (int i = 0; i <=1000; i++) {
            if (i%5==0) {
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0) {
                System.out.print("\n");
            }
            //System.out.println();
            //println 自动换行
        }
    }
}

package Struct;
public class ForLianxi2 {
    public static void main(String[] args) {
        for (int j = 1; j < 10; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(i + "*" + j + "=" + (j * i) + "\t");
            }
            System.out.print("\n");
        }
        System.out.println("--------------");
        int[] number = {1, 2, 3, 4, 5};
        for (int x : number) {
            System.out.print(x+"\t");
            //增强for
        }
        System.out.println();
        System.out.println("---------------");
        for (int i = 1; i <=100; i++) {
            if (i % 5 == 0) {
                System.out.println("中止位置");
                continue;
            }
            System.out.print(i+"\t");
            //continue 终止本次循环不会退出循环。
        }
        System.out.println("------------");
       outer://外层循环添加标签
        for (int i = 101; i < 150; i++) {
            //设置outer标签判断条件
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println("-------------");
        //打印三角形
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--)
                System.out.print(" *");
            for (int j = 1; j <= i; j++)
                System.out.print(" &");
            for (int j = 1; j < i; j++)
                System.out.print(" &");
            for (int j = 5; j >= i; j--)
                System.out.print(" *");
            System.out.println("");
        }
    }
}

11.Scanner类

Scanner类是从键盘获取数据

package Scannerxi;
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        // 创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            String str= scanner.next();
            System.out.println("内容输出为:"+str);
        }
        scanner.close();
    }
}

package Scannerxi;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        scanner.hasNextLine();
        if (scanner.hasNextLine()){
        String cc =scanner.nextLine();
        System.out.println( "内容输出为:"+cc);

    }
        scanner.close();
     }

}

package Scannerxi;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        //从键盘接收数据
        int a=0;
        float b=0.0f;
        System.out.println("请输入数据");
        if (scanner.hasNextInt())
        {
            a = scanner.nextInt();
            System.out.println("整数数据：" + a);
        }
         else{
            System.out.println("输入的不是整数数据:" );
        }
        System.out.println("请输入小数：");
        if(scanner.hasNextFloat()){
            b=scanner.nextFloat();
            System.out.println( "小数数据："+b);
        }
        else{
            System.out.println("输入的不是小数数据：");
        scanner.close();
            }
    }
}

package Scannerxi;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        //输入多个数字，并求其总和与平均数；每一个数字输入完成后用回车确认，通过非数字结束输入并输出结果
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数据：");
        double sum=0;
        //和
        int a=0;
        //计算输入了多少个数字
        while(scanner.hasNextDouble()) {
            double x = scanner.nextDouble();
            a = a + 1;
            sum = sum + x;
            System.out.println(a+"和为"+sum);
            System.out.println(a+"平均值为"+(sum/a));
        }
        scanner.close();
    }
}

12.break\continue\retrun的区别

break：常用于终止退出循环
continue：用于中止循坏，不退出循环
retrun：终止方法

13.方法定义和调用及重载

   修饰词 返回值类型 方法名（...）{
   
    方法体....
    
    return 返回值
    }

package Array;
//类
public class fangfa {
    //main 方法（主程序）
    public static void main(String[] args) {
        System.out.println(new fangfa().max(1,2));//方法调用
    }
    /*修饰词 返回值类型 方法名（...）{
    方法体
    return 返回值
    }
     */
    public String sayHello(){
        return "hello world";
    }
    public void  /*空*/  hello(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
    //静态方法
    public static void say(){
    }
    //非静态方法
    public void sayi(){
    }
}

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法重载规则
1.方法名必须相同
2.参数列表必须不同（个数不同，或类型不同、或参数排列顺序不同）
3.方法的返回值可以相同也可以不同
4.仅仅返回类型不同不足以成为方法的重载

11.可变参数

package method;

public class keBiancanshu {
    public static void main(String[] args) {
        keBiancanshu keBiancanshu = new keBiancanshu();
        keBiancanshu.test(1);
        System.out.println("-----------");
        printMax(22,535,55,66);
        printMax(new double[]{1,5,6,7,33,66});

    }
    public void test(int...i){
        System.out.println(i[0]);

    }
    public static void printMax(double... number){//可变参数符号 ... 可以定义无限个参数
        if (number.length==0){
            System.out.println("N0 argument passed");
            return;
        }
        double result=number[0];
        for (int i = 1; i < number.length; i++) {
            if (number[i]>result){
                result =number[i];
            }
        }
        System.out.println("The max value is "+result);
    }

}

12.递归

递归头：什么时候不调用自身方法，如果没有递归头将陷入死循环
递归提：什么时候调用自己

package method;

public class DIgui {
    public static void main(String[] args) {
        System.out.println(f(6)
        );
    }

    public  static  int f(int n){
        if (n==1){
            return 1;
        }
        else{
            //3*f（n-）=3*f（2）
            return n*f(n-1);//阶乘
        }
    }
}

13.数组的声明和创建

package Array;

public class ArraySm {
    public static void main(String[] args) {
        int[]a;//声明一个数组
        a=new int[5];//创建一个数组
        a[0]=1;//给数组元素赋值
        a[1]=2;//给数组元素赋值
        a[2]=3;//给数组元素赋值
        a[3]=4;//给数组元素赋值
        a[4]=5;//给数组元素赋值
    }
}

14.内存分析

1.堆：存放new 的对象和数组，可以被所有的线程共享，不会存放别的对象引用
2.栈：存放基本变量类型（包含基本类型的具体值），引用对象的变量（会存放引用在堆里的具体地址）
3.方法区：可以被所有的线程共享，包含了所有的clss和static变量

16.数组使用

package Array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        //遍历数组 for each
        for (int i : a) {//for(int 数组元素：数组名）
            System.out.println(i);
        }
        System.out.println("----------------");
        //打印所有元素
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("--------------");
        //计算所有元素的和
        double ax = 0;
        for (int i = 0; i < a.length; i++) {

            ax += a[i];

        }
        System.out.println("ax和为:" + ax);
        System.out.println("---------------");
        //查找最大元素
          int max = 0;
        for (int i = 0; i < a.length; i++) {

            if (a[i] > max) {
                max = a[i];
            }
            System.out.println("max:" + max);
        }

        int[] b = new int[10]; //动态初始化
        b[0] = 1;
        b[9] = 11;
        //静态初始化
        int[] c = {1,2,3,4};
        // System.out.println();
        System.out.println("---------");
        //printa(a);
        System.out.println("\n---------");
        int[] reverse = reverse(a);
        printa(reverse(a));
    }

    //定义一个方法
    //打印一个数组 数组作为方法入参
    public static void printa(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
    //反转数组 数组作为返回值
    public static int[]reverse(int[] a){
        int[]result =new int[a.length];
        for (int i = 0,j= result.length-1; i < a.length; i++,j--) {
            result[j]=a[i];

        }
        return (result);
    }
}

17.多维数组

即二维数组可以看成是特殊的一维数组（数组的嵌套）

18.arrays类

1.数组的工具类：java.util.Arrays
2.Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用而没必要再使用对象来调用
3.常用方法
给数组赋值：通过fill方法
对数组排序：通过sort方法升序
比较数组：通过equals方法比较元素值是否相等
查找数组元素：通过binarySearch方法对排序好的数组进行二分查找法操作

19.冒泡排序

package Array;

import java.util.Arrays;

//冒泡排序
public class maopaopaixun {
    public static void main(String[] args) {
        //比较数组中，两个相邻元素，如果第一个数比第二个数大，就交换他们的位置
        //每比较一次，就会产生一个最大和最小的数
        //下一轮可减少一次排序
        //依次循环，直到结束
        int temp = 0;
        int[] a = {1, 33, 4, 42, 3, 23, 424, 55, 2, 55, 23, 452,};
        //外层循环 判断要走多少次
        for (int i = 0; i < a.length; i++) {
            //判断是否大小一致，不用比较
            boolean flag;
            flag = false;
            //内层循环 比较两个数，第一个数比第二个数大 就交换位置
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j + 1] > a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false) {
                break;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

20.稀疏数组

package Array;

public class xishushuzu {
    public static void main(String[] args) {
        //创建一个数组11*11 0-没有棋子 1-黑棋 2-白棋
        int [][]arrays1 =new int[11][11];
        arrays1[1][2]=1;
        arrays1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);
        //创建一个稀疏数组
        int[][]arrays2= new int[sum+1][3];
        arrays2[0][0]=11;
        arrays2[0][1]=11;
        arrays2[0][2]=sum;
        //遍历二维数组 将非零的值，存放稀疏数组中
        int count=0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j] != 0) {
                    count++;
                    arrays2[count][0]=i;
                    arrays2[count][1]=i;
                    arrays2[count][2]=arrays1[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
        for (int i = 0; i < arrays2.length; i++) {
            System.out.println(arrays2[i][0]+"\t"
                    +arrays2[i][1]+"\t"
                    +arrays2[i][2]);
        }
        System.out.println("----------");
        System.out.println("还原");
        //都取稀疏数组
        int[][]arrays3=new int[arrays2[0][0]][arrays2[0][1]];
        //给其中的元素还原值
        for (int i = 1; i < arrays2.length; i++) {
            arrays3[arrays2[i][0]][arrays2[i][1]]=arrays2[i][2];
        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : arrays3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

内容总结

以上是互联网集市为您收集整理的JAVA基础语法和实战全部内容，希望文章能够帮你解决JAVA基础语法和实战所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/614574.html

来源：【匿名】

【上一篇】Java 注解（Annotation）--基础篇【下一篇】JAVA/JSP学习系列之五

更多 ►

【JAVA基础语法和实战】教程文章相关的互联网学习教程文章

Java 基础 Java平台的3个版本

Java平台有3个版本：适用于小型设备和智能卡的JavaME（Java Platform Micro Edition，Java微型版）、适用于桌面系统的JavaSE（Java Platform Standard Edition，Java标准版）和适用于企业级应用的JavaEE（Java Platform Enterprise Edition）。而JavaEE是一个开发企业级应用的规范和标准，在现在的企业级开发中最为常用，最受开发者的青睐。　　参考资料JavaEE的相关技术原文：https://www.cnblogs.com/WJQ2017/p/8401382.html

Java基础面试题集（二）

Java程序员面试题集（1-50）一、Java基础部分1、面向对象的特征有哪些方面?答：面向对象的特征主要有以下几个方面：1)抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。2)继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。3)封装：通常认...

java基础学习（四）【代码】

java基础学习（四）十二、包装类十三、Object类十四、System类十五、数组十二、包装类序号基本数据类型包装类1byteByte2shortShort3intInteger4longLong5charCharacter6floatFloat7doubleDouble8booleanBoolean2.Integer类常用方法：方法返回值功能byteValue()byte以 byte 类型返回该 Integer 的值shortValue()short以 short 类型返回该 Integer 的值intValue()int以 int 类型返回该 Integer 的值toString()String返回一个表示该...

java基础——集合【代码】【图】

集合与数组的区别： 1.数组是固定长度的；集合的长度是可变的。 2.数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。 3.数组存储元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。 java集合主要有3种重要的类型： ●List：是一个有序集合，可以存放重复的数据。 ●Set: 是一个无序集合，不允许存放重复的数据。 ●Map: 是一个无序集合，集合中包含一个键对象和一个值对象，键对象不...

Java基础四【图】

Java基础四一、Switch语句二、if和switch区别推荐使用if 三、函数Java中的函数和方法是同一个词四、数组4.1、数组常见错误五、内存机制六、转换成十六进制移位&操作6.2 查表法求十六进制查表法很多时候都非常好用，这样就非常好了，真的非常好用算的时候直接移四位，我喜欢，我觉得以后可以多做移位运算，真的是简单方便 6.3 查表法求星期几原文：http://www.cnblogs.com/Renyi-Fan/p/6883048.html

java基础（十三）常用类总结（三）【代码】

这里有我之前上课总结的一些知识点以及代码大部分是老师讲的笔记个人认为是非常好的，，也是比较经典的内容，真诚的希望这些对于那些想学习的人有所帮助！由于代码是分模块的上传非常的不便。也比较多，讲的也是比较清晰的！如果你有需要可以在评论中留下您的邮箱我看到一定会免费发给你的！感谢这个平台让我们大家共同进步吧！！记住程序员是无私的！！！也非常欢迎到我的博客内观看博客地址：http://www.cnblogs.com/duscl/ ...

Java基本基础【图】

之前学习了.net，感觉还好，不过发现了几句话很有含义：有的女人就是Windows虽然很优秀，但是安全隐患太大。有的女人就是MFC她条件很好，然而不是谁都能玩的起。有的女人就是C#长的很漂亮，但是家务活不行。有的女人就是C++,她会默默的为你做很多的事情。有的女人就是汇编虽然很麻烦，但是有的时候还得求它。有的女人就是SQL，她会为你的发展带来莫大的帮助。不过现在是学Java了，今天通过学习了Java的，简单的描述java语法：...

java基础——String和StringBuffer的区别

首先在java中有三个类来操作字符串：Character 是进行单个字符操作的;String 对一串字符进行操作。不可变类;StringBuffer 也是对一串字符进行操作，但是可变类String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.String 是final类,即不能被继承.StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象它只...

Java基础之绑定

绑定绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定. 静态绑定在程序执行前方法已经被绑定（也就是说在编译过程中就已经知道这个方法到底是哪个类中的方法），此时由编译器或其它连接程序实现。例如：Ｃ。针对java简单的可以理解为程序编译期的绑定；这里特别说明一点，java当中的方法只有final，static，private和构造方法是前期绑定动态绑定 ...

Java_Day05 Java基础

1. 抽象类和一般类的区别 : 1) 抽象类使用 abstract 修饰 2) 抽象类不能被实例化 3) 抽象类中可以有抽象方法,也可以没有抽象方法2. - 使用 interface 声明 - 接口是抽象方法和常量的集合, 不能再有其他任何成分 - 接口中的方法默认修饰为 public abstract - 接口中常量的默认修饰为 public static final - 实现接口使用 implements 关键字 - 一个类可以实现多个接口, 多个接口之间使用逗号分隔 - 接口之间...

【Java基础】类型转换【代码】【图】

1publicclass Demo2 {2publicstaticvoid main(String[] args) {3//byte/short/char->int->long->float->double4// 低->高5//运算中，不同类型的数据要先转换成同一类型，再进行运算。 6int i = 128;7byte b = (byte)i; //存在内存溢出的问题高->低 8double d = i;// 低->高 9 System.out.println(i); 10 System.out.println(b); 1112//强制转换（类型）变量名高->低 13//自动转换低->高1415/*16 注...

java基础面试题

1.什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”?Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。 2.JDK和JRE的区别是什么?Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它...

Think in Java(一)：Java基础

一. OOP的特点(1) 万物皆为对象; (2) 程序是对象的集合，他们通过发送信息来告诉彼此所要做的; (3) 每一个对象都有自己的由其它对象所构成的存储; (4) 每一个对象都拥有它的类型; (5) 某一特定类型的对象都能够接收相同的消息;二. Java比C++简单?(1) Java有垃圾回收器, 不用手动销毁对象; (2) Java使用单根继承; (3) Java仅仅能以一种方式创建对象(在堆上创建);三. 数据存储 (1) 寄存器: 速度最快, 数量有限, 它位于CPU内部, 但我们...

Java基础Day3【代码】【图】

Java基础第三天Java基础第三天1.1赋值运算符符号： = （1）当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。 (2)支持连续赋值。扩展赋值运算符： +=, -=, *=, /=, %= 思考1： short s = 3; s=s+2; ① s+=2; ② ①和②有什么区别？扩展赋值运算符不改变数据类型思考2：boolean b1 = false; //区分好==和=的区别。 if(b1=true)System.out.printl...

java基础第六章课后习题【图】

1.说明循环结构中break语句和continue语句的区别。在循环结构中 break语句是结束程序运行。 continue语句是结束本句程序不是结束程序。2.使用for循环结构实现，从键盘上接受从周一至周五每天学习时间，并计算每日平均学习时间。输出结果。3.鸡兔同笼问题。今有鸡兔同笼，上有35头，下有94足，问鸡兔各几只？试编写程序解决问题。4.开发一个标题为“ FlipFlop”的游戏应用程序。它从 1 计数到100 ，遇到3的倍数输出单词“ Flip...

首页 / JAVA / JAVA基础语法和实战

JAVA基础语法和实战

内容导读

内容图文

Java小节：

1.博客

2.makerdowm语法

3. 冯?诺依曼体系结构

4.注释

5.数据基本类型及引用类型（primitive type、reference type）

6.类型转换

7.变量

8. 运算符

9.包机制

10.顺序结构、if选择结构、swich结构、while、do while结构、for、for增强结构

11.Scanner类

12.break\continue\retrun的区别

13.方法定义和调用及重载

11.可变参数

12.递归

13.数组的声明和创建

14.内存分析

16.数组使用

17.多维数组

18.arrays类

19.冒泡排序

20.稀疏数组

内容总结

内容备注

内容手机端

【JAVA基础语法和实战】教程文章相关的互联网学习教程文章

JAVA - 相关标签

语法 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程