java笔记-基础

fan__lee

已于 2022-05-12 11:55:28 修改

阅读量247

点赞数

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

于 2020-09-04 09:35:56 首次发布

本文链接：https://blog.csdn.net/fan__lee/article/details/108356025

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

JVM:java虚拟机，位于操作系统和用户之间，运行所有Java程序的抽象计算机，是Java语言的运行环境，它是Java 最具吸引力的特性之一。
垃圾回收机制：
C/C++由程序员回收，手动编写代码回收，其
JDK包含JRE/
JRE包括JVM和JAva程序所需的所有类库
命名规范：
在这里插入图片描述

编译和注释

新建文件：新建txt,改名HelloWorld.java
编译代码：命令行输入 javac HelloWorld.java生成class文件，然后再输入java HelloWorld执行
编写代码：

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello Java");
    }
}

public 表示这是一个可以公开访问的类
class 表示这是一个类
HelloWorld 表示类的名字，每个单词的首字母大写
注意：类的名字应该和文件的名字保持相同
public static void main(String[] args) 这是主方法，写法固定。所有代码的入口

'单行注释'：//
多行注释：
'普通多行注释：'
/*
注释
注释
*/
'特殊的多行注释：特殊的多行注释需要写在类和方法的定义处，可以用于自动创建文档。'
/**
*这是注释
*这也是注释
*@author lyp
*/

面向对象：

在这里插入图片描述
面向对象更像是先设计出出各种模块，然后拼起来。而面向过程像是直接按照流程制造，不可复用。
类：类是一个模版，里面有很多属性和方法，供对象使用
对象：对象是类的一个实例
属性：就是实例所要有的属性。也就是例子中一个英雄（类）有姓名，血量，护甲等等状态
方法：能做什么在类里面就叫做方法。LOL中，一个英雄可以做很多事情，比如超神，超鬼，坑队友
以下图为例：
在这里插入图片描述
定义的英雄就是一个类，是一个模版。garen,teemo就是两个对象。据这样一个模板，可以创建一个个的具体的英雄.
方法的使用和定义：：

'有返回类型的：'
int/float 方法名(参数){
    return armor;
}
如：
float getArmor(){
  return armor;
}
'无返回类型的：把返回类型设置为void,表示该方法不返回任何值'
void keng(){
  System.out.println("坑队友！");
}
'方法中的参数也是根据需要添加：'
void addSpeed(int speed){
  //在原来的基础上增加移动速度
  moveSpeed = moveSpeed + speed;
}
'对象可以调用方法：'
garen.legendary()
'也可以在输出中调用：'
ystem.out.println(garen.name + "回复后血量是：" + garen.getHp());

定义的代码：

package j2se;

public class Hero {
	String name; //姓名
    
    float hp; //血量
     
    float armor; //护甲
     
    int moveSpeed; //移动速度
    
    void legendary(){
    	System.out.println("你超神了");
    }
    
    void recovery(float blood){
    	hp = hp + blood;
    }
    
    float getHp(){
    	return hp;
    }
    
    float getArmor(){
    	return armor;
    }
    
    void addSpeed(int speed){
    	moveSpeed = moveSpeed + speed;
    }
    
    public static void main(String[] args){
    	Hero garen = new Hero();
    	garen.name = "盖伦";
    	garen.hp = 616.28f;
    	garen.armor = 27.536f;
    	garen.moveSpeed = 350;
    	garen.addSpeed(100);
    	garen.recovery(100);
    	System.out.println(garen.name + "回复后血量是：" + garen.getHp());
    	
    	Hero teemo = new Hero();
    	teemo.name = "提莫";
        teemo.hp = 383f;
        teemo.armor = 14f;
        teemo.moveSpeed = 330;
    }
    
}

好的习惯：
类的第一个字母大写–
属性名称一般来说，都是小写比如name。如果有多个单词组成，后面的单词的第一个字母大写moveSpeed
方法是一个类的动作行为，所以一般都是以动词开头的，比如 keng …如果有多个单词，后面的每个单词的第一个字母使用大写
关键字：都是预先定义的，特有的。
保留字：现在Java版本还没使用，但是以后的版本里会使用，这些词就尽量不要在代码中使用。

变量

1)变量的定义是：用来命名一个数据的标识符

int year = 1949;
`year`就是一个变量
`int` 是数据类型，表示是整数
`year` 是一个标识符
`=` 是赋值操作符
`1949` 是一个数字类型的值
`;` 表示该行结束

2)变量的使用
1、变量分为基本类型变量和引用类型变量

数据类型

分为基本数据类型（int …）和引用数据类型(类(String属于类)，接口，数组)。
整型变量：byte-short-int-long
整型默认是int，如果是long的，需要加L或者l
在这里插入图片描述

字符型：
char类型用于存放一个字符，值用单引号'表示 (双引号表示字符串)
其长度和short一样，也是16位的
只能存放一个字符，超过一个字符就会产生编译错误

char c = '中';

浮点型：
浮点数类型有两种
float 长度为32位
double 长度为64位
注意：默认的小数值是double类型的
所以 float f = 54.321会出现编译错误，**因为54.321的默认类型是 double，其类型长度为64，超过了float的长度32
在数字后面加一个字母f，直接把该数字声明成float类型float f2 = 54.321f,这样就不会出错了
布尔型：
布尔型用于表示真假，长度为1
但是，不能直接使用0 1 进行赋值
在这里插入图片描述
String类型：
String类型其实并不是基本类型，但是它是如此广泛的被使用，常常被误以为是一种基本类型。
String类型是Immutable的，一旦创建就不能够被改变

String str = "Hello Java";

package Variate;

public class VariateType {
	public static void main(String[] args) {
		double a = 3.14;
		double b = 2.769343;
		short c = 365;
		byte d = 12;
		char e = '吃';
		boolean f = false;
		String description="不可描述";
	}
}

赋值：

基本类型

给基本类型的变量赋值的方式叫做 字面值，如下所例：

int a;//如果是局部变量，必须要初始化，程序不会自动赋值，而全局变量会自动赋值
float hp = 313f;
int armor = 24;

整数字面值

public class HelloWorld {
    public static void main(String[] args) {
        long val = 26L; //以L结尾的字面值表示long型
        int decVal = 26; //默认就是int型
        int hexVal = 0x1a; //16进制
        int oxVal = 032; //8进制
        int binVal = 0b11010; //2进制
        System.out.println(oxVal);
    }
}

当以l或者L结尾的时候，一个整数字面值是long类型，否则就是int类型。建议使用大写的L而非小写的l，因为容易和1混淆

浮点数字面值

当以f或者F结尾的时候，就表示一个float类型的浮点数，否则就是double类型（以d或者D结尾，写不写都可以）。
浮点数还可以用E或者e表示（科学计数法）
e2表示10的二次方，即100 ,1.234e2 = 1.234x100

public class HelloWorld {
 
    public static void main(String[] args) {
        float f1 = 123.4F;// 以F结尾的字面值表示float类型
        double d1 = 123.4;// 默认就是double类型
        double d2 = 1.234e2;// 科学计数法表示double
    }
}

字符

字符的字面值放在单引号中
字符串的字面值放在双引号中（但是字符串不是基本类型）

public class HelloWorld {
 
    public static void main(String[] args) {
        String name = "盖伦";
        char a= 'c';
 
        //以下是转义字符
        char tab = '\t'; //制表符
        char carriageReturn = '\r'; //回车
        char newLine = '\n'; //换行
        char doubleQuote = '\"'; //双引号
        char singleQuote = '\''; //单引号
        char backslash = '\\'; //反斜杠
         
    }
}

boolean

boolean  a = true;//真
a = false; //假

数组类型

数据转换：

不同类型之间的数据可以互相转换，但是要满足一定的规则
转换规则：
精度高的数据类型就像容量大的杯子，可以放更大的数据
精度低的数据类型就像容量小的杯子，只能放更小的数据
注意：虽然short和char都是16位的，长度是一样的，但是彼此之间，依然需要进行强制转换

byte-->short-->int-->long-->float-->double

byte，short，char之间不会转换，三者的计算都是先转换为int。
多个数据类型互相转换，会转化成最大的那种类型
任何数据类型和字符串进行+运算，结果都是字符串(“1”+2+3结果就是字符串123)
当有一些列的+的运算的时候。如果某个部分其中含有字符串，那么这个字符串前边挨着的进行+运算，往后都要按照字符串拼凑去看(1+2+3+“a”+2+6=6a26)
’a‘+1+"H"=98H(a的ASCii码值是97),“H”+‘a’+1=Ha1
boolean类型不能转换为其他基本类型

public class HelloWorld {
   public static void main(String[] args) {
        char c = 'A';
        short s = 80;     
        //虽然short和char都是16位的，长度是一样的
        //但是彼此之间，依然需要进行强制转换
        c = (char) s;
        //直接进行转换，会出现编译错误
        s = c;      
    }
}

低精度向高精度转换:
是低精度向高精度转换是可以正常转换的,
在这里插入图片描述

long l = 50;
int i = 50;
l =  i;

高精度向低精度转换:

byte b = 5;
int i1 = 10;
int i2 = 300;
b = i1;
b=i2;

有的时候是可以转换的，比如 b = i1 (i1=10);
有的时候不可以转换比如 b= i2 (i2=300) ，就会造成数据丢失，因为放不下了。

public class HelloWorld {
  
    public static void main(String[] args) {
  
        byte b = 5;
        int i1 = 10;
        int i2 = 300;
          
        b = (byte) i1;
        //因为i1的值是在byte范围之内，所以即便进行强制转换
        //最后得到的值，也是10
        System.out.println(b);
          
        //因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取
        //i2的值是300，其对应的二进制数是 100101100
        //按照byte的长度8位进行截取后，其值为 00101100 即44
        b =(byte) i2;
        System.out.println(b);
         
        //查看一个整数对应的二进制的方法：
        System.out.println(Integer.toBinaryString(i2));
         
    }
}

short/char/byte可以进行加法运算，但会在运算时将数据自动转换为int类型再运算，结果为int 类型。

变量命名

能够自己起名字的叫做标识符
变量命名：
只能使用字母数字 $ _
且第一个字符只能说字母而不能是数字
使用完整的单词命名，而非缩写
不能只使用关键字，但是可以包含关键字class5
在这里插入图片描述

中文也是可以用来命名变量的，但是一般不使用。
变量作用域：
和C相同，只在其所属的块起作用
变量处于不同的位置，有不同的名称，分别是：
1 字段，属性

public class HelloWorld {
    int i = 1;
    int j = i;  //其他的属性可以访问i
    public void method1(){
        System.out.println(i); //方法1里可以访问i
    }
    public void method2(){
        System.out.println(i); //方法2里可以访问i
    }
}

2 参数

public class HelloWorld {
 
    public void method1(int i){ //参数i的作用域即方法method1
        System.out.println(i);
    }
    public void method2(){
 
        System.out.println(i); //method2 不能访问参数i
    }
     
    int j = i;  //类里面也不能访问参数i
}

3 局部变量

public class HelloWorld {
 
    public void method1() {
        int i  = 5;  //其作用范围是从声明的第4行，到其所处于的块结束12行位置
        System.out.println(i);
        {            //子块
            System.out.println(i); //可以访问i
            int j = 6;
            System.out.println(j); //可以访问j
        }
        System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
    }
 
}

变量final-表达式-块

final 修饰一个变量，有很多种说法，比如不能改变等等
准确的描述是当一个变量被final修饰的时候，该变量只有一次赋值的机会
定义变量的时候，如果加上final修饰符，这个变量就变成了常量

public class HelloWorld {
 
    public void method1() {
        final int I = 5;         
        i = 10; //i在第4行已经被赋值过了，所以这里会出现编译错误      
    }
}

public class HelloWorld { 
    public void method1() {
        final int i;         
        i = 10; //i在第4行，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值         
        i = 11; //i在第6行已经被赋值过了，所以这里会出现编译错误        
    }
}

final 除了修饰变量，还可以修饰类，修饰方法.
以;结尾的一段代码，即为一个表达式
//一个空;也是一个表达式
从{ 开始到对应的} 结束，即一个块

操作符

基本算数操作符

+, -, *, /

两数相加：

package j2se;
import java.util.Scanner;

public class lian {
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		int a = s.nextInt();
		System.out.println("第一个整数："+a);
		float b = s.nextFloat();
		System.out.println("第二个整数："+b);
		float c = a + b;
		System.out.println("a + b =" +c);
	}
}

任意运算单元的长度超过/小于int

如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算
如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算

'超过int'
int a = 5;
long b = 6;
a+b -> 结果类型是long
所以要进行强制转换：int c = (int) (a+b);
'小于int'
int a = 20
byte b = 1
a + b ->结果类型是int
所以要进行强制类型转换：byte c = (byte) (a + b )
不强制转换就需要： int c = a + b

%取模 (% 取余数，又叫取模)

自增自减

i++; 先取值，再运算
++i; 先运算，再取值

关系操作符:比较两个变量之间的关系

> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等

逻辑运算符

在这里插入图片描述
长路与/或两侧，都会被运算
短路与/或只要第一个是false/true，第二个就不进行运算了

位操作符(移位运算)：

在这里插入图片描述在计算机中，整数总是以二进制的形式表示。例如，int类型的整数7使用4字节表示的二进制如下：

00000000 0000000 0000000 00000111

1、左移
可以对整数进行移位运算。对整数7左移1位将得到整数14，左移两位将得到整数28：

int n = 7;       // 00000000 00000000 00000000 00000111 = 7
int a = n << 1;  // 00000000 00000000 00000000 00001110 = 14
int b = n << 2;  // 00000000 00000000 00000000 00011100 = 28
int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192
int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912

左移29位时，由于最高位变成1，因此结果变成了负数（是因为影响移到了符号位）。
2、右移
如果对一个负数进行右移，最高位的1不动，结果仍然是一个负数

int n = -536870912;
int a = n >> 1;  // 11110000 00000000 00000000 00000000 = -268435456
int b = n >> 2;  // 11111000 00000000 00000000 00000000 = -134217728
int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2
int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1

移位运算首先要明确的是在计算机中正数用二进制原码表示的，负数用补码表示的。
在右移时，补码是符号位；
在左移时，补码永远都是0；而无符号移位只有右移，没有左移，补码永远都是0。
记忆的话只要记住**“右移补符其它补0”**即可。

对byte和short类型进行移位时，会首先转换为int再进行位移。
仔细观察可发现，左移实际上就是不断地×2，右移实际上就是不断地÷2。

赋值运算符：

在这里插入图片描述

三元运算符：(表达式?值1:值2;如果表达式为真返回值1;如果表达式为假返回值2)

Scanner(输入)

整数、浮点数、字符串：

import java.util.Scanner;
 
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int a = s.nextInt(); //整数输入
        System.out.println("第一个整数："+a);
        float b = s.nextFloat();//浮点数输入
        System.out.println("第二个数："+b);
        String c = s.nextLine();//字符串输入
        System.out.println("读取的字符串是："+c);
    }
}

如果是读取了整数后，接着读取字符串：

需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".
所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串

package j2se;
import java.util.Scanner;

public class lian {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        System.out.println("读取的整数是"+ i);
        String rn = s.nextLine();
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}

控制流程：

if

if (){...}
if () {...} if (){...}
if () {...} else if(){...} else {...}

package j2se;
import java.util.Scanner;

public class lian {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int b = 1;
        if (b==1){
        	 int i = s.nextInt();
             System.out.println("读取的整数是"+ i);
        }
        else if (b==2){
        	String rn = s.nextLine();
            String a = s.nextLine();
            System.out.println("读取的字符串是："+a);
        }    
    }
}

switch

switch可以使用byte,short,int,char,String,enum

注: 每个表达式结束，都应该有一个break;
注: String在Java1.7之前是不支持的, Java从1.7开始支持switch用String的，编译后是把String转化为hash值，其实还是整数
注: enum是枚举类型，在枚举章节有详细讲解

package j2se;
import java.util.Scanner;

public class lian {
    public static void main(String[] args) {
    	int day = 5;
    	switch(day){
        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;
        default:
            System.out.println("这个是什么鬼？");
    }   
    }
}

while{…} do{…至少执行一次}while;

练习：通过Scanner 获取一个整数，然后使用while计算这个整数的阶乘

package j2se;
import java.util.Scanner;

public class lian {
    public static void main(String[] args) {
    	Scanner s = new Scanner(System.in);
    	int a = s.nextInt();
    	System.out.println("输入的整数是：" +a);
    	int sum = 1;
    	while (a>0){
    		sum = sum * a;
    		a = a-1;
    	}
    	System.out.println("a!=" +sum);
    }
}

for （int j = 0; j < 5; j++）

练习：天朝有一个乞丐姓洪，去天桥要钱
第一天要了1块钱
第二天要了2块钱
第三天要了4块钱
第四天要了8块钱
以此类推
问题：洪乞丐干10天，收入是多少？

package j2se;
import java.util.Scanner;

public class lian {
    public static void main(String[] args) {
    	int money = 1;
    	for (int i=1;i<11;i++){
    		if (i==1){
    			money = 1;
    		}
    		else{
    			money *= 2;
    		}
    	}
    	System.out.println("共乞讨：" +money + "元");
    }
}

continue/break

continue:跳出本次循环继续下一次循环
break:结束整个循环

借助boolean变量/标签结束外部循环

借助boolean变量结束外部循环
需要在内部循环中修改这个变量值
每次内部循环结束后，都要在外部循环中判断，这个变量的值

public class HelloWorld {
    public static void main(String[] args) {
        boolean breakout = false; //是否终止外部循环的标记
        for (int i = 0; i < 10; i++){ 
            for (int j = 0; j < 10; j++) {
                System.out.println(i + ":" + j);
                if (0 == j % 2) {
                    breakout = true; //终止外部循环的标记设置为true
                    break;
                }
            }
            if (breakout) //判断是否终止外部循环
                break;
        }
    }
}

public class HelloWorld {
    public static void main(String[] args) {
          
        //打印单数    
        outloop: //outloop这个标示是可以自定义的比如outloop1,ol2,out5
        for (int i = 0; i < 10; i++) {
             
            for (int j = 0; j < 10; j++) {
                System.out.println(i+":"+j);
                if(0==j%2) 
                    break outloop; //如果是双数，结束外部循环
            }
             
        }
         
    }
}