java基础笔记

目录

1.Java程序基本结构
2.变量和数据类型
3.整数运算
4.字符和字符串
5.数组类型
6.输入
7.if语句
8.三木运算
9.switch多重选择
10.while循环
11.do while循环
12.for循环
13.break和continue
14.类中方法的声明和使用

Java程序基本结构

    public class Hello {// 类名是Hello
        public static void main(String[] args) {// 方法名是main
            // 向屏幕输出文本:
            System.out.println("Hello, world!");
        }
    } // class定义结束

变量和数据类型

 * Java提供了两种变量类型：基本类型和引用类型
    * 基本数据类型
        * 1.整数类型:byte  short  int  long  整数类型，默认类型为int型
            * int x =100;
            * long a = 12213l(他必须在后面加l或者L)
        * 2.浮点数类型: float double 浮点型常量，默认类型为double型
            * float f1 = 3.14f;(他必须在后面加f)
            * double d3 = 4.9e-324
        * 3.字符类型: char    (字符类型char表示一个字符)
            * char ch ='1'
        * 4.布尔值类型: (boolean 布尔类型boolean只有true和false两个值)
    * 整形表示的大致范围
        * byte：-128 ~ 127
        * short: -32768 ~ 32767
        * int: -2147483648 ~ 2147483647
        * long: -9223372036854775808 ~ 922337203685477580   在他后面必须加L或者l
    * 引用数据类型 
        * String类型变量的使用
            1. String属于引用数据类型,翻译为：字符串
            2. 声明String类型变量时，使用一对""
            3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
            4. 运算的结果仍然是String类型

整数运算

自增/自减

    int n = 100;
    int a=n++;
    int b=++n;
    System.out.println(n);//102
    System.out.println(a);//100
    System.out.println(b);//102
    注意++写在前面和后面计算结果是不同的，
    ++n表示先加1再引用n，n++表示先引用n再加1。
    不建议把++运算混入到常规运算中，容易自己把自己搞懵了。

位运算

位运算是按位进行与、或、非和异或的运算。
与  & (与运算的规则是，必须两个数同时为1，结果才为1：)
或  | (或运算的规则是，只要任意一个为1，结果就为1：)
非  = (非运算的规则是，0和1互换：)
异或 ^ (异或运算的规则是，如果两个数不同，结果为1，否则为0)

类型自动提升与强制转型

在运算过程中，如果参与运算的两个数类型不一致，那么计算结果为较大类型的整型。
例如，short和int计算，结果总是int，原因是short首先自动被转型为int：

    public class Main {
        public static void main(String[] args) {
            short s = 1234;
            int i = 123456;
            int x = s + i; // s自动转型为int
            short y = s + i; // 编译错误!
        }
    }

也可以将结果强制转型，即将大范围的整数转型为小范围的整数。
强制转型使用(类型)，例如，将int强制转型为short：

public class Main {
    public static void main(String[] args) {
        int i1 = 1234567;
        short s1 = (short) i1; // -10617
        System.out.println(s1);
        int i2 = 12345678;
        short s2 = (short) i2; // 24910
        System.out.println(s2);
    }
}

字符和字符串

字符类型

字符类型char是基本数据类型，它是character的缩写
一个char保存一个Unicode字符

字符串的类型

和char类型不同，字符串类型String是引用类型，我们用双引号"..."表示字符串。
一个字符串可以存储0个到任意个字符
可以使用+连接任意字符串和其他数据类型
常见的转义字符包括：
\" 表示字符"
\' 表示字符'
\\ 表示字符\
\n 表示换行符
\r 表示回车符
\t 表示Tab
\u#### 表示一个Unicode编码的字符

数组类型

定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]。
和单个基本类型变量不同，数组变量初始化必须使用new
int[5]表示创建一个可容纳5个int元素的数组。
要访问数组中的某一个元素，需要使用索引。数组索引从0开始(也叫下标)
可以用数组变量length获取数组大小
Java的数组有几个特点：
    数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
    数组一旦创建后，大小就不可改变。

    String [] str = {"java","JavaScript","css"} //字符串数组
    int[] ns = { 68, 79, 91, 85, 62 };//整形数组
    索引  --->   0   1   2    3   4
    ns.length//获取数组的长度
    

输入

import java.util.Scanner;//引入包
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        String name = scanner.nextLine(); // 读取一行输入并获取字符串
        System.out.printf(name); // 格式化输出
    }
}

if语句

基本语法
if (条件) {
    // 条件满足时执行
}if else(条件){
    // 条件满足时执行
}else{
    // 条件满足时执行
}

三木运算

基本语法 (条件)?条件为true执行:条件为false执行

switch多重选择

语法
switch (option) {
    case 3:
        ...
        break;
    case 2:
        ...
        break;
    case 1:
        ...
        break;
}

    如果遗漏了break，就会造成严重的逻辑错误，而且不易在源代码中发现错误。
    从Java 12开始，switch语句升级为更简洁的表达式语法，
    注意新语法使用->，
    如果有多条语句，需要用{}括起来。
    不要写break语句，因为新语法只会执行匹配的语句，没有穿透效应
public class Main {
    public static void main(String[] args) {
        String fruit = "apple";
        switch (fruit) {
        case "apple" -> System.out.println("Selected apple");
        case "pear" -> System.out.println("Selected pear");
        case "mango" -> {
            System.out.println("Selected mango");
            System.out.println("Good choice!");
        }
        default -> System.out.println("No fruit selected");
        }
    }
}

但是，如果需要复杂的语句，我们也可以写很多语句，放到{...}里，
然后，用yield返回一个值作为switch语句的返回值
public class Main {
    public static void main(String[] args) {
        String fruit = "orange";
        int opt = switch (fruit) {
            case "apple" -> 1;
            case "pear", "mango" -> 2;
            default -> {
                int code = fruit.hashCode();
                yield code; // switch语句返回值
            }
        };
        System.out.println("opt = " + opt);
    }
}

while循环

语法
while (条件表达式) {
循环语句
}
// 继续执行后续代码

例子
public class Main {
    public static void main(String[] args) {
        int sum = 0; // 累加的和，初始化为0
        int n = 1;
        while (n <= 100) { // 循环条件是n <= 100
            sum = sum + n; // 把n累加到sum中
            n ++; // n自身加1
        }
        System.out.println(sum); // 5050
    }
}
注意:
    到while循环是先判断循环条件，再循环，因此，有可能一次循环都不做。
    如果循环条件永远满足，那这个循环就变成了死循环。
    表面上看，上面的while循环是一个死循环，但是，Java的int类型有最大值，
    达到最大值后，再加1会变成负数，结果，意外退出了while循环。

do while循环

语句
do {
    执行循环语句
} while (条件表达式);
while循环是先判断循环条件，再执行循环。
而另一种do while循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出。
可见，do while循环会至少循环一次。

例子:
public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int n = 1;
        do {
            sum = sum + n;
            n ++;
        } while (n <= 100);
        System.out.println(sum);
    }
}

for循环

语法
for (初始条件; 循环检测条件; 循环后更新计数器) {
    // 执行语句
}

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1; i<=100; i++) {
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

break和continue

break

在循环过程中，可以使用break语句跳出当前循环
注意:break语句总是跳出自己所在的那一层循环

continue

ontinue则是提前结束本次循环，直接继续执行下次循环
在多层嵌套的循环中，continue语句同样是结束本次自己所在的循环。

类中方法的声明和使用

类中方法的声明和使用
方法：描述类应该具有的功能。
    比如：Math类：sqrt()\random() \...  
    Scanner类：nextXxx() ...
    Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
1.举例：
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}
2. 方法的声明：权限修饰符  返回值类型  方法名(形参列表){
        方法体
}
#注意：static、final、abstract 来修饰的方法，后面再讲。
3. 说明：
    3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
    Java规定的4种权限修饰符：private、public、缺省、protected
    3.2 返回值类型： 有返回值  vs 没有返回值
        3.2.1  如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
        如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
    3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
    3.4 形参列表： 方法可以声明0个，1个，或多个形参。
        3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
    3.5 方法体：方法功能的体现。 		
4.return关键字的使用：
    1.使用范围：使用在方法体中
    2.作用：① 结束方法② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
    3.注意点：return关键字后面不可以声明执行语句。
5. 方法的使用中，可以调用当前类的属性或方法
    特殊的：方法A中又调用了方法A:递归方法。方法中，不可以定义方法。
    

例子

public class CustomerTest {
	public static void main(String[] args) {
		Customer cust1 = new Customer();
		cust1.eat();
		cust1.sleep(8);
		
	}
}
//客户类
class Customer{
	//属性
	String name;
	int age;
	boolean isMale;
	//方法
	public void eat(){
		System.out.println("客户吃饭");
		return;
		//return后不可以声明表达式
	}
	public void sleep(int hour){
		System.out.println("休息了" + hour + "个小时");
		eat();
	}
	public String getName(){
		
		if(age > 18){
			return name;
			
		}else{
			return "Tom";
		}
	}
	public String getNation(String nation){
		String info = "我的国籍是：" + nation;
		return info;
	}
}

java四种权限$\color{red}{修饰符}$的区别

java提供了四种访问权限修饰符，使用不同的访问权限修饰符是，被修饰的内容有不同的访问权限：public：公共的所有地方都可以访问
    protected 当前类，当前包，当前类的所有子类都可以访问
    缺省（没有修饰符） 当前包，当前类可以访问
    private 私有的，当前类可以访问
public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
成员变量使用private ，隐藏细节。
构造方法使用public ，方便创建对象。
成员方法使用public ，方便调用方法。
不加权限修饰符，就是default权限

相关资料

java教程 - 廖雪峰的官方网站
www.cnblogs.com/kt-ting/p/1…
www.liaoxuefeng.com/wiki/125259…