Java相关基础知识小总结

2021/10/30 20:16:22

本文主要是介绍Java相关基础知识小总结,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

引言:这是本人学习java过程总结一些基础知识和简单案例

Java开发工具包:安装JDK

JDK目录介绍:


                 1、JDK/bin:存放许多命令,如:javac.exe(负责编译)和 java.exe(负责运行)

                 2、开发HelloWord.java源程序【照抄,不要问why,注意大小写】


              
                JDK,JRE,JVM三者之间的关系,以及JDK,JRE包含的主要结构
                    
                JDK=JRE+JAVA的开发工具(javac.exe java.exe javadoc.exe)
                    
                JRE=JVM+JAVA核心类库
   
          
             
                3、将HelloWord.java源程序通过javac工具进行编译:

                     首先确定javac命令是否可用,在DOS命令窗口,输入javac,回车,若出现'java'不是内部或外部命令,也不是运行程序或处理 文件,因为windows操作无法找到javac命令文件

                     *处理javac不可用问题:
                               windows操作系统如何搜索硬盘某个命令?
                                              1、从当前目录下搜索
                                              2、若在当前目录找不到,从环境变量path指定路径搜索某个命令
                                              3、再搜索不到,则报以上是错误

      

配置环境变量: 

  1、安装完成后,右击"我的电脑",点击"属性",选择"高级系统设置"                

 2、选择"高级"选项卡,点击"环境变量"

 3、在个人用户变量新建JAVA_HOME、PATH两个属性,若已存在则点击"编辑"

        变量名:JAVA_HOME

        变量值:F:\software\install\Java_11       // 要根据自己的实际路径配置

        变量名:PATH

        变量值:%JAVA_HOME%\bin

 4、在系统变量新建PATH属性,若已存在则点击"编辑"

        变量名:PATH

        变量值:%JAVA_HOME%\bin

5、测试JDK安装是否成功

        1、按住Win+R键,键入"cmd";

        2、键入命令: java -versionjavajavac 几个命令,出现以下信息,说明环境变量配置成功;

 

Java包括三大块:

                                1、JavaSE(Java标准版)
                                2、JavaEE(Java企业版)   
                                3、JavaME(Java微型版)
                  JavaSE是基础,以后主要方向是JavaEE方向

Java语言特性【开源、免费、纯面向对象、跨平台】:

         1、简单性:屏蔽指针的概念(C++实现Java语言底层),不是C语言
         2、面向对象:更符合人的思维模式,更容易理解
         可移植性:Java程序可以做到一次编译,到处运行,不做任何修改,放到 windows、Linux操作系统运行(跨平台)

         3、由于两个操作系统内核不同,执行指令也不一样,所以Java程序不能直接和操作系统打交道

         4、为了实现Java程序和底层操作系统打交道,让Java运作一台虚拟计算机【JVM】

         5、多线程:按照分解成多个子任务,每个子任务称为一个线程,共同完成主任务的运行过程,可以缩短时间,提高服务效率
         6、健壮性:Java语言运行中产生的垃圾是自动回收的【简称GC机制】
         7、安全性:JVM可以阻止系统外产生的副作用,Java语言中适当限制增强了安全性 (扩:Java编译器输出的并不是可执行代码,而是字节代码【bytecode】)
                     java API文档:将语言提供的类库,称为api.  

开始第一个Java程序

// 创建一个Java源文件:HelloWorld.java
         
                   public class HelloWorld {
                       /*这是第一个Java程序
                       *它将打印Hello World
                       *这是一个多行注释
                       */
                          public static void main(String []args) {
                              //这是单行注释,也是程序的入口                                                
                              /**这个也是单行注释**/
                                    System.out.println("Hello World");//打印 Hello World
          }
       }

Java中名称命名规范


                  *包名:都要用小写
                  *类名,接口名:首字母都要大写
                  *变量名,方法名:第一个单词小写,第二个单词大写
                  *常量名:所有字母大写,如果是多单词用下划线连接

Java程序运行包括两个重要的阶段:

        1、编译阶段:符合Java语则生成正常的字节文件(并非是纯粹的二进制)
              过程:新建一个.java扩展名文件(源文件),里面编写的是Java源代码/源程序【符合Java语则,需要记忆】,使用当中自带javac.exe命令进行Java程序编译,javac java源文件路径在DOS命令窗口使用,javac是一个java编译器工具/命令

           *一个java源文件可以编写生成多个.class文件
 
           *最终要执行的文件是字节码文件/class文件(删不删除java程序并不影响
            java程序的执行,但是一般java源程序不要删除)

           *编译结束后,将class文件拷贝到其他操作系统中运行【跨平台】               
       
        2、运行阶段:JDK安装完成后(自带一个javac.exe),此外还有一个工具/命令,叫做java.exe(命令主要负责运行阶段)

              * java.exe在DOS命令窗口使用
                       *例:硬盘上有一个HelloWorld.class,那么就这样用:java HelloWorld
             
               *注:千万不要写成java HelloWorld.class【是错误的】
                       前面有public class后面名称一定和java文件名称一样                         
                       编译和运行两个过程不能有“异常”出现

                         过程:
                                1、打开DOS命令窗口
                                2、输入:java A
                                3、java.exe命令启动JVM,JVM会启动类加载器classLoader
                                4、classLoader去硬盘搜索A.class文件,找到该文件将字节文件装载到JVM中
                                5、JVM解释字节文件(A.class)以二进制1010101010数据
                                6、然后操作系统执行二进制和底层硬件平台交互

数据类型:

    
                1、整型:byte int short long
                2、浮点型:float double
                3、字符型:char
                4、布尔型:boolean

       优先级:

                 由低到高: boolean,byte,short,char—> int —> long—> float —> double

      自动类型转换:从低级别到高级别,系统自动转的

      强制类型转换:什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量

运算符:

               1、算术运算符:+  -  *  /   “+”(连接符)  ++(前加加1  先加后用;反之,后加加1   先用后加)  --(前减减1  先加后用;反之,后减减1   先用后加)

               2、赋值运算符:= += -= *= /= %=

               3、比较运算符:比较结果要么是true,要么是false

               4、逻辑运算符:& | ^ ! && ||

                                            False && False     False

                                            False && True     False

                                            False || True    True

               5、位运算符(用于操作二进制位的运算符):& | ^& << >> >>>(无符号右移)

关键字:

        专门用的字符串(单词),所有的字母都要小写

                        (1)48个关键字:abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while.

                        (2)2个保留字(现在没用以后可能用到作为关键字):goto、const.

                        (3)3个特殊直接量:true、false、null.


标识符:

        凡是自己可以起名字的地方(对各种变量,方法和类命名使用的字符序列)        

              *注:  1、标识符有字母、数字、_(下划线)、$所组成,其中不能以数字开头,不能用Java中的保留字(关键字)

                        2、标识符采用有意义的简单命名

                        3、"$"不要在代码中出现。(是由于在后面内部类中,编译后会出现$符号)

循环语句:

        - for, while 及 do...while

for(初始部分;判断条件;迭代部分){
        // 代码语句

}

while(判断部分){
   // 循环体              
   // 迭代部分(不能漏掉),否则是死循环
                        
}

// 初始化
 do
{ 
// 循环体  迭代部分 
}while(判断部分)
// 先执行后判断

   

分支语句:

        if(-else if)-else 语句和switch语句

if(判断部分){
   // 如果布尔表达式的值为true
}else{
   // 如果布尔表达式的值为false
}


// 多层判断
if(判断部分){
   // 判断1
}else if(判断部分){
   // 判断2
}else if(判断部分){
   // 判断3
}else{
  //执行最后
}


// 嵌套式
    // 外
if(判断部分){
    // 内
    if(判断部分){
         // 如果布尔表达式的值为true
    }else{
         // 如果布尔表达式的值为false
    }
}else{
     // 执行最后
}


switch(){ // 里面参数只能是int short String类型

       case: 常量1;
           // 语句1
       case: 常量2;
           // 语句2
       case: 常量3;
           // 语句3
        ...
       default: // 其他情况
           // 语句4
 
       break; // 跳出 
       }
   // switch-case根据switch表达式中的值,依次匹配case中的值,一旦匹配成功,就执行相应case结构中的语句,调用完后继续执行case中的语句,直到遇到break,或者switch-case结构的结尾,跳出switch-case结构

 案例

    计算当前总天数

import java.util.Scanner;

public class Araby
{
	public static void main(String[] args)
    {
			@SuppressWarnings("resource")
			Scanner scan=new Scanner(System.in);
			System.out.print("请输入年份:");
			int year=scan.nextInt();
			System.out.print("请输入月份:");
			int month=scan.nextInt();
			System.out.print("请输入天数:");
			int day=scan.nextInt();
			int sunDay=0;
			switch(month)
            {
                case 12:

                    sunDay +=30;

                case 11:

                    sunDay +=31;

                case 10:

                    sunDay +=30;

                case 9:

                    sunDay +=31;

                case 8:

                    sunDay +=31;

                case 7:

                    sunDay +=30;

                case 6:

                    sunDay +=31;

                case 5:

                    sunDay +=30;

                case 4:

                    sunDay +=31;

                case 3:
                    if((year%4==0&&year%100!=0)||year%400==0)
                    {
                    }
                    else
                    {
                        sunDay +=28;
                    }
                        case 2:
                        sunDay +=31;
                        case 1:
                        sunDay +=day;
                    }
			        System.out.println(year+"年"+month+"月"+day+"日\t总过了:"+sunDay+"天了!");
			}
}
		
		
		
		
		   
		   
	

	

        判断某年属于什么生肖年?

import java.util.Scanner;

public class ChiZod
{
		public static void main(String[] args)
        {
			@SuppressWarnings("resource")
			Scanner input = new Scanner(System.in);
			System.out.print("请输入年份:");
			int year = input.nextInt();
			switch(year%12)
            {
				case 0:
					System.out.println("猴年");
					break;
				case 1:
					System.out.println("鸡年");
					break;
				case 2:
					System.out.println("狗年");
					break;
				case 3:
					System.out.println("猪年");
					break;
				case 4:
					System.out.println("鼠年");
					break;
				case 5:
					System.out.println("牛年");
					break;
				case 6:
					System.out.println("虎年");
					break;
				case 7:
					System.out.println("兔年");
					break;
				case 8:
					System.out.println("龙年");
					break;
				case 9:
					System.out.println("蛇年");
					break;
				case 10:
					System.out.println("马年");
					break;
				case 11:
					System.out.println("羊年");
					break;
			}
		}
	}

        判断数组里的最大值与最小值

public class ComSiz
{
	public static void main(String[] args)
    {
			int i;
			int arr[] = new int[]{8,3,88,9,23};
			//int arr[] = {,,,}
			int max = arr[0];
			//将第一项赋给max
			int min = arr[0];
			//将第一项赋给min
		for(i=0;i<arr.length;i++)
		{	
			//遍历数组中所有元素
			if(arr[i]>max)
			{
				/*arr[0] > arr[0]  flase
				 * arr[1] > arr[0] flase
				 * arr[2] > arr[0]  true
				 * arr[3] > arr[2] flase
				 * arr[4] > arr[2] flase
				 * max = arr[2]**/
				max = arr[i];
			}
			if(arr[i]<min)
			{
				/*arr[0] < arr[0]  flase
				 * arr[1] < arr[0] true
				 * arr[2] < arr[1] flase
				 * arr[3] < arr[1] flase
				 * arr[4] < arr[1] flase
				 * min = arr[2]**/
				min = arr[i];
			}
		}
			System.out.println("max="+max);
			System.out.println("min="+min);
	}
}

         九九乘法表

public class Test1
            {
                public static void main(String[] args)
                {
                    int i,j;//定义变量
                    for(i=1i<=9;i++)
                    {
                        /**
                        for(初始化;判断条件;迭代部分)
                        **/
                        //外循环控制行数
                        for(j=1;j<=i;j++)
                        {
                            //内循环控制每行的表达式个数
                            System.out.print(i+"*"+j+"="+j*i+"\t");//打印表达式
                        }
                        	System.out.println();//打印并换行
                    }
                }
            }

        计算器

public class Test3 extends JFrame
            {
                public Test3()
                {
                        Container co2 = this.getContentPane();
                        co2.setLayout(new GridLayout(4,5));
                        JLabel jl1 = new JLabel("+");
                        JLabel jl2 = new JLabel("*");
                        JLabel jl3 = new JLabel("-");
                        JLabel jl4 = new JLabel("/");
                        JTextField jt3 = new JTextField(10);
                        JTextField jt4 = new JTextField(10);
                        JTextField jt5 = new JTextField(10);
                        JTextField jt6 = new JTextField(10);
                        JTextField jt7 = new JTextField(10);
                        JTextField jt8 = new JTextField(10);
                        JTextField jt9 = new JTextField(10);
                        JTextField jt10 = new JTextField(10);
                        JTextField jt11 = new JTextField(10);
                        JTextField jt12 = new JTextField(10);
                        JTextField jt13 = new JTextField(10);
                        JTextField jt14 = new JTextField(10);
                        JButton jb3 = new JButton("=");
                        JButton jb4 = new JButton("=");
                        JButton jb5 = new JButton("=");
                        JButton jb6 = new JButton("=");
                        JPanel jp5 = new JPanel();
                        JPanel jp6 = new JPanel();
                        JPanel jp7 = new JPanel();
                        JPanel jp8 = new JPanel();
                        co2.add(jp5);
                        jp5.add(jt3);
                        jp5.add(jl1);
                        jp5.add(jt4);
                        jp5.add(jb3);
                        jp5.add(jt5);
                    
                        co2.add(jp6);
                        jp6.add(jt6);
                        jp6.add(jl2);
                        jp6.add(jt7);
                        jp6.add(jb4);
                        jp6.add(jt8);
                    
                        co2.add(jp7);
                        jp7.add(jt9);
                        jp7.add(jl3);
                        jp7.add(jt10);
                        jp7.add(jb5);
                        jp7.add(jt11);
                    
                        co2.add(jp8);
                        jp8.add(jt12);
                        jp8.add(jl4);
                        jp8.add(jt13);
                        jp8.add(jb6);
                        jp8.add(jt14);
                  		jb3.addActionListener(e ->{//注册监听器
                            if (e.getSource()==jb3)
                            {
                               // e.getSource()可以获得,e:表示一个事件
                                int a  = Integer.parseInt(jt3.getText());//定义一个整型变量a接收jt3的值
                                int b = Integer.parseInt(jt4.getText());
                                int c = a + b;//定义一个变量c接收a,b的和
                                jt5.setText(""+c);//得出最后的结果
                            }
                        });
                        jb4.addActionListener(e1 ->{
                            if (e1.getSource()==jb4)
                            {
                                int d  = Integer.parseInt(jt6.getText());
                                int e = Integer.parseInt(jt7.getText());
                                int f = d - e;
                                jt8.setText(""+f);
                            }
      				   });
       				   jb5.addActionListener(e2 ->{
                            if (e2.getSource()==jb5)
                            {
                                int g  = Integer.parseInt(jt9.getText());
                                int h = Integer.parseInt(jt10.getText());
                                int i = g * h;
                                jt11.setText(""+i);
                            }
                        });
       				 jb6.addActionListener(e3 ->{
                            if (e3.getSource()==jb6)
                            {
                                int j  = Integer.parseInt(jt12.getText());
                                int k = Integer.parseInt(jt13.getText());
                                int l = j / k;
                                jt14.setText(""+l);
                            }
                        });
                        this.setTitle("我的计算器");
                        this.setBounds(300,400,600,400);
                        this.setVisible(true);
                 }
                public static void main(String[] args)
                {
                    new Test3();
                }
            }


这篇关于Java相关基础知识小总结的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程