Java基础

Magic_Hell

已于 2023-06-03 17:19:18 修改

阅读量41

点赞数 1

分类专栏： JavaSE 文章标签： java

于 2023-05-29 19:15:03 首次发布

本文链接：https://blog.csdn.net/Magic_Hell/article/details/130934692

版权

这篇博客详细介绍了Java的基础知识，包括Java的三个版本、JDK和JRE的区别、Java程序的执行流程、数据类型、循环控制语句、面向对象的特性、类与对象的概念、继承、多态以及静态成员和抽象类、接口的使用。内容覆盖了从Java环境配置到高级特性的多个方面。

摘要由CSDN通过智能技术生成

第一讲

javaSE：java Standard Edition
javaME：java Micro Edition
javaEE：java Enterprise Edition

JDK:java Development Kit（Java开发包）
JRE:java Runtime Environment(java执行环境)
JDK包含了JRE

如何查询Java版本
java -version

在这里插入图片描述

实现你的第一个Java程序{Hello World}

注：所有的Java代码，其后缀都是以Java结尾

public class Text{
  public static void main {String[] args}{
       System.out.println("hello world");
  }
}

java程序的执行过程分为两步

编译 Javac Text.java
执行 java Text
最后就会出现Hello World了

class 文件是字节码文件，程序最终执行的就是这个字节码（bytecode）文件

第二讲

java中的数据类型分为两类：

原生数据类型（primitive Data Type）
引用数据类型｛对象类型｝（Reference Type）

java中的原生数据类型共有8种

整型：使用int表示。

public class Text{
   
    public static void main (String[] args){
   
        int a;
        a = 1;
        System.out.println(a);    
    }
}

字节型：使用byte表示。（表示-128~127之间的256个整数）

public class Text{
   
    public static void main(String[] args){
   
        byte b = 2;
        System.out.println(b);
    }
}

短整型：使用short表示。（占比16位）
长整型：使用long表示。（占比64位）
单精度浮点型：使用float表示。所谓浮点型，指的就是小数。也叫作实数。
双精度浮点型：使用double表示。双精度浮点型表示的数据范围要比单精度浮点型要大。
即便double类型的值处于float类型的范围内也是不可以的。总之，能否成功赋值取决于等号右边的值的类型与等号左边的值的类型是否一致。
问：如何将double类型转换为float类型的变量？
答: 强制转换，强制转换的语法是：类型变量名 = （类型）变量值

public class Text{
   
    public static void main (String[] args){
   
        /*第一种方法*/
        float a =(float) 1.2;//强制转换
        System.out.println(a);

        /*第二种方法*/
        float a =1.2f;//强制转换
        System.out.println(a);
    }
}

字符型：使用char表示（char是character的缩写）。所谓的字符，就是单个的字符表示，比如字母a,或中文张，外面用单引号包围上，比如char a = ‘b’; char b = ‘张’；

public class Text{
   
    public static void main(String[] args){
   
        char a = 'b';
        System.out.println(a);
    }
}

布尔类型，使用boolean表示。布尔类型只有两种可能值，分别是true或者是flase。

public class Text{
   
    public static void main (String[] args){
   
        boolean  a = flase;
        System.out,println(a);
    }
}

可以将表示范围小的值赋给表示范围大的变量，但直接不能将表示范围大的值赋给表示范围小的变量，只能通过强制类型转换实现。

第三讲

java中所有浮点类型默认情况下都是double。不能将double类型的值赋给float类型的变量，即便该double类型的值处于float类型的范围内也是不可以的。总之，能否成功赋值取决于等号右边的值的类型与等号左边的变量类型是否一致
如何将double类型的值赋给float类型的变量？
强制类型转换，将double类型的值强制转换为float类型
强制转换的语法：类型变量名 = （类型）变量值
变量在使用前必须要赋值；变量必须要声明其类型方可使用；变量在使用前必须要定义，并且只能定义一次。

第四讲

当有若干个变量参与运算时，结果类型取决于这些变量中表示范围最大的那个变量类型。

比如：参与运算的变量中，有整型 int ，有双精度浮点型double，有短整型short，那么最后的结果类型就是double。

public class test{
   
    public static void main (String[] args){
   
        int a = 1;
        int b = 2;
        
        int c = a + b;//3
        int d = a - b;//-1
        int e = a/b;//0
        int f = a*b;//2
        System.out.println(c); 
        System.out.println(d); 
        System.out.println(e); 
        System.out.println(f); 
    }
}

public class Text{
   
    public static void main (String[] args){
   
        double a = 1;//出现double都让路
        int b = 2;

        double c = a + b;
        double d = a - b;
        double e = a/b;
        double f = a*b;
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
        System.out.println(f);
    }
}

下面的代码中，a 和 b 都是整型，但是通过（double）a这种转换将a转换为一个匿名的变量，该变量的类型是double，但是要注意：a本身依旧是int类型，而不是double类型，这样。(double)a/b就是double类型除以int类型，结果自然是double类型。

public class Text{
   
    public static void main (String[] args){
   
        int a = 1;
        int b = 2;
        double e = (double) a/b;
        System.out.println(e);
    }
}

取模运算符：使用%表示。【取模的规律：取模的结果符号永远与被除数的符号相同】

public class text{
   
   public static void main (String[] args){
   
       int a = 5;
       int b = 3;
       int c = a % b;
       System.out.println (c);
   }
}

第五讲

关系运算符：大于（>），小于（<），等于（==），不等于（!=），大于等于（>=）,小于等于（<=），关系运算的结果是个boolean值。

public class text{
   
    public static void main (String[] args){
   
        int a = 3 ;
        int b = 2 ;

        boolean c = ( a>b );
        System.out.println(c);
    }
}
/*结果显示（true）*/

2.逻辑运算符：重点讲解两个，逻辑运算符本身也返回一个boolean值。

1）逻辑与：使用&&表示，逻辑与是个双目运算符（即有两个操作数的运算符），只有当两个操作数都为真的时候，结果才为真；其余均为假。（逻辑与表示的并且的意思）

public class test {
   
	public static void main (String[] args){
   
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        
        boolean e = (a < b) && (c < d);
        System.out.println(e);
    }
}
/*结果显示：true*/

2）逻辑或：使用||表示，逻辑或也是个双目运算符，只有当两个操作数都为假的时候，结果才为假；其余情况都为真。（逻辑或表示或者的意思）

public static void main(String[] args){
   
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;

        boolean e = (a<b)||(c<d);
        System.out.println(e);
    }
}
/*结果显示：true*/

3）关于逻辑运算符的短路特性。

逻辑与：如果第一个操作数为flase，那么结果肯定就是flase，所以在这种情况下，，将不会执行后面的运算了，即发现了短路现象。
逻辑或：如果第一个操作数为true，那么结果肯定就是true，所在在这种情况下，将不会执行逻辑或后面的运算了，即发生了短路现象

public class test {
   
	public static void main (String[] args){
   
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        int f = 5;
        boolean e = (a > b)||((f = c) < d);
        System.out.println(e); 
        System.out.println(f);
   }
}
/* 结果是：true
          5
*/

4）关于变量的自增与自减运算
1.关于 int b = a++,作用是将a的值先赋给b，然后再让a自增1。
2.关于 int b = ++a,作用是将a的值先自增1，然后将自增后的结果赋给b。

public class test {
   
    public static void main (String [] args){
   
        int a = 3;
        //a += 1;//等价于 a = a + 1;
        a++;
        
        System.out.println(a);
    }
}
/*结果是：4*/

public class test {
   
    public static void main (String [] args){
   
        int a = 3;
        //a += 1;//等价于 a = a + 1;
        ++a;
        
        System.out.println(a);
    }
}
/*结果是：4

public class test {
   
    public static void main (String [] args){
   
        int a = 3;
        //a += 1;//等价于 a = a + 1;
        a--;
        
        System.out.println(a);
    }
}
/*结果是：2*/

public class test {
   
    public static void main (String [] args){
   
        int a = 3;
        //a += 1;//等价于 a = a + 1;
        --a;
        
        System.out.println(a);
    }
}
/*结果是：2*/

第七讲

java中的循环控制语句一共有三种，分别是while，do…while以及for循环。
1）while循环，形式为：

while (布尔表达式){
    //待执行的代码
}

public class Text{
   
    public static void main (String[] args){
   
        int a = 1;//循环变量
        int sum = 0;//存储相加后的变量
        
        while(a <= 100){
   
            sum += a;
            a++;76
    }
}
/*结果是：5050*/

2）do…while循环，形式为：

do{
    //待执行的代码
}while(布尔表达式);

public class test {
   
    public static void main (String[] args){
   
        int a = 1;
        int sum = 0;

        do{
   
            sum += a;
            a++;
        }while(a<=100);
        System.out.println(sum);
    }
}
/*结果是：5050*/

while与do…while之间的区别：如果布尔表达式的第一次判断就为false，那么while循环一次也不执行；do…while循环则会执行一次。如果布尔表达式第一次判断为true，那么while循环与do…while循环等价。
3）for循环（使用最多的一种循环），形式为：

for(变量初始化；条件判断；步进){
   //待执行的代码
}

for循环的执行过程：
1）执行变量初始化。
2）执行条件判断。如果条件判断结果为假，那么退出for循环，开始执行循环后面的代码；如果条件判断为真，执行for循环里面的代码。
3）执行步进。
4）重复步骤2。

public class test{
   
    public static void main (String[] args){
   
        int sum = 0;//存储相加后的结果
        for(in

最低0.47元/天解锁文章

Magic_Hell

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础

相对于抽象方法，之前所定义的方法叫做具体方法（有声明，有实现）
复制链接

扫一扫

专栏目录