java 基础

注释

作用：

可以用来对代码的说明
可以用来注释代码，被注释的代码在程序运行时，不会执行。

单行注释

单行注释：用//表示。

点击查看代码

public String hello(Model model){
        // 这是单行注释，对代码的解释说明
        model.addAttribute("msg","test_thymeleaf");
        // System.out.println("调试中....");
        return "a";
    }

}

多行注释

多行注释：用/*..*/表示。

点击查看代码

public static void say(){
        /*
            这是演示代码
            可以注释多行文字
         */
        System.out.println("演示代码...");
        /*
        String name = "mark";
        int age = 18;
        System.out.println(name);
         */
        System.out.println(age);
    }

文档注释

文档注释：对程序功能类、方法等做一些说明。用/**...*/表示。

点击查看代码

/**
     * 这是一个**的方法说明
     * @param model 参数
     * @return 返回值
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        // 这是单行注释
        model.addAttribute("msg","test_thymeleaf");
        // System.out.println("调试中....");
        return "a";
    }

标识符、关键字

java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

标识符注意点

所有标识符都应该以字母(A-Z或者a-z),美元符$,或者下划线_开始。
首字符之后可以是字母(A-Z或者a-z),美元符$,或者下划线_或数字的任何字符组合。
不能使用关键字作为变量名或方法名。
标识符大小写敏感。

数据类型

java是一种强类型语言，要求变量使用严格符合规定，所有变量必须先定义后使用。

数据类型转换

由于java是强类型语言，所以在进行某些数学运算的时候，需要做类型转换。
低---------------------------------------------------->高
byte,short,char --> int --> long --> float --> double
运算时，需要将不同类型转换成同一类型，然后再做运算。

注意点

不能对布尔类型进行转换。
不能把对象类型转换为不相干的类型。
在把高容量转换到低容量的时候，强制转换。
转换的时候可能存在内存溢出，或者精度问题。

强制类型转换

从高位----> 低位

自动类型转换

从低位----> 高位

变量

java是强类型语言，每个变量都必须声明类型。

java变量是程序中最基本的存储单元，其要素包括：变量名、变量类型和作用域。

每个变量都有类型，类型可以是基本类型，也可以是引用类型。

变量必须是合法的标识符。

变量声明是一条完整的语句，因此每个声明都必须以;号结束。

例如：

点击查看代码

String name = "张三"；
int age = 18；

变量作用域

类变量
实例变量
局部变量

类变量

定义在类中，方法体外且由关键字static修饰的标识符，从属于类，调用方式类名.变量名。

点击查看代码

public class Demo{
	// 类变量 name
	static String name;
	public static void main(String[] args){
		// 类变量调用方式:类名.变量名
		System.out.println(Demo.name);
	}
}

实例变量

定义在类中，方法体之外的标识符，从属于对象，调用方式对象名.变量名。
如不自行初始化，对应类型的变量初始化值为：

int 默认 0.0；

boolean 默认 false;

除基本类型，其余默认都是 null；

点击查看代码

public class Demo{
	// 类变量 name
	static String name;
	public static void main(String[] args){
		// 实例化一个对象
		Demo demo = new Demo();
		// 调用方式:对象名.变量名
		System.out.println(demo.name);
	}
}

局部变量

定义在方法中的标识符，从属于方法，只在方法中有效。

点击查看代码

public class Demo{
	// 类变量 name
	static String name;
	public static void main(String[] args){
		// 实例化一个对象
		Demo demo = new Demo();
		// 调用方式:对象名.变量名
		System.out.println(demo.name);
	}

	public void say(){
	// age 只在方法中有效，并且变量名age必须初始化才可使用。
	int age = 18;
	System.out.println(age);
	}
}

常量

初始化后不能再改变值，不会变动的值。是一种特殊的变量，一般用关键字final修饰，常量一般大写表示。

变量命名规范

所有变量、方法、类名：见名知意。
类成员变量：首字母小写和驼峰原则：monthSalary。
局部变量：首字母小写和驼峰原则。
常量：大写字母和下划线：MAX_VALUE。
类名：首字母大写和驼峰原则：Man,GoodMan。
方法名：首字母小写和驼峰原则：run(),RunUp()。

运算符

java支持以下运算符：

算数运算符：+、-、*、/、%、++、--

赋值运算符：=

关系运算符：>,<,>=,<=,==,!=,instanceof

逻辑运算符：&&、||、！

条件运算符：？

扩展赋值运算符：+=、-=、*=、/=

位运算符：&、|、^、~、>>、<<、>>> (了解！)

三元运算符（条件运算符）：x ? y : z x == true,返回 y，否则返回 z
运算符的优先级最高的是(),所以要表示最高优先运算用()操作

java程序结构-顺序结构

java程序最基本的结构是 顺序结构，除非特别指明，否则就按照顺序一步一步的往下执行。

顺序结构是最简单的算法结构。

语句与语句之间，框架与框架之间是按照从上到下的顺序进行的。它是由若干个依次执行的步骤组成的。

java程序结构-选择结构

程序运行过程中，需要根据不同的判断，实现不同的业务逻辑。此时就需要用到选择结构。java常见的选择结构有:

if单选择结构

if双选择结构

if多选择结构

嵌套的if结构

switch多选择结构

if单选择结构

点击查看代码

语法：
if（布尔表达式）{
  //如果布尔表达式为true将执行
}
public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容: ");
        String s = scanner.nextLine();
	// 如果输入的字符串是"hello"，则输出s,否则不执行if当中的语句
        if (s.equals("hello")) {
            System.out.println(s);
        }
        System.out.println("end");
        scanner.close();
    }

if双选择结构

点击查看代码

语法：
if(表达式){
  // 为true,执行...
}else{
  // if表达式为false,执行...
}
public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容: ");
        String s = scanner.nextLine();
        if (s.equals("hello")) {
            System.out.println(s);
        }else{
            System.out.println("输入错误");
        }
        scanner.close();
    }

if多选择结构

多选择条件时，只要有一个条件满足，程序就走这个满足条件的语句，其他条件不会走。

点击查看代码

语法：
if(表达式1){
  //表达式1 true,执行....
}else if(表达式2){
  //表达式2 true，执行...
}else if(表达式3){
  //表达式3 true,执行...
}else{
  //上述条件都不满足时，执行....
}

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入分数: ");
        int score = scanner.nextInt();
        if (score>=90) {
            System.out.println("优秀");
        }else if（score>=80）{
            System.out.println("良好");
        }else if(score>=70){
            System.out.println("中等");
        }else if(score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }

嵌套if结构

点击查看代码

语法：
if(表达式1){
  // if嵌套
  if(表达式2){
    //表达式2 true,执行....
  }
}

switch多选择结构

switch case语句判断一个变量与一系列值中的某个值是否相等，每个值被看做一个分支。

switch语句中的变量类型可以是 byte,short,int或者char。

java SE7开始变量类型还支持String类型。

break 防止case穿透。

点击查看代码

语法：
switch（表达式）{
  case value1:
    语句1...
	break;
  case value2:
    语句2...
	break;
  case value3:
    语句3...
	break;
  ...
  default:    //这步可选
    语句...
}

public static void main(String[] args) {
        char gen = 'C';
        switch (gen){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("挂科");
                break;
        }
    }

java程序结构-循环结构

在程序执行过程中，需要对某些业务做循环操作，可以使用循环结构。java常见的循环结构有:

while循环

do..while循环

for循环，java SE5后还引入了针对数组的增强型for循环。

while循环

while循环是最基本的循环结构。

一般情况下我们都会让程序循环停止下来，所以我们需要一个表达式来结束循环。

条件一直为true时，很容易造成死循环。

点击查看代码

语法：
while(表达式){
  //条件为true,执行语句...
}
public static void main(String[] args) {
        int i = 0;
		while(i小于10){
		i++;
		System.out.println(i);
		}
}

do...while循环

do...while循环和while循环类似，不同的是，do...while循环至少会执行一次。
while循环是先判断后执行，do...while是先执行一次，在判断。

格式

点击查看代码

代码先执行do语句中的代码，然后在判断while条件是否成立，成立则继续循环，直到条件不成立跳出循环。
do{
  执行语句//
}while(表达式)

for循环

学习的重点
for循环是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for循环执行的次数在开始前就确定了。

语法

点击查看代码

for(初始化;表达式;更新){
//执行语句...
}

public static void main(String[] args) {
      for (int i = 0; i 小于10; i++) {
          System.out.println(i);
	}
}

增强for循环

主要用于遍历数组或集合。

语法

点击查看代码

for(声明语句:表达式){
//执行语句...
}

public static void main(String[] args) {
        int[] intList = {10,20,32,54,66,88};
        for (int i:intList) {
            System.out.println(i);
        }
    }

java中方法

java方法是语句的集合，用来执行一个功能。

java方法是解决一类问题的步骤的有序组合。

方法包含在类或对象中。

方法在程序中创建，在其他地方被调用。

设计方法的原则，保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后续的维护和扩展。

方法的定义和调用

java方法类似其他语言的函数，是一段用来完成特定功能的代码集合。

方法定义

方法包含：

修饰符：约定方法的访问类型。

返回值类型: 定义方法返回值的类型，无返回值时，void表示。

方法名：方法的实际名称。

参数类型：形参，定义方法时的参数;实参，调用方法时传入的参数。

方法体：具体的功能语句。

方法名+参数共同构成方法签名。

点击查看代码

定义方法
public static int sum(int a,int b){
        return a+b;
    }

方法调用

调用方法：对象名.方法名(实参列表）或 类名.方法名(实参列表）。

点击查看代码

public class MyTests {
    public static void main(String[] args) {
        // 方法调用 MyTests.sum(3, 5)
        int sum = MyTests.sum(3, 5);
        System.out.println(sum);
    }

    // 方法定义
    public static int sum(int a,int b){
        return a+b;
    }
}

方法的重载

在同一个类中，函数名称相同，但形参不同。构成了重载，重载只针对方法来说。

方法重载规则

方法名称必须相同

参数列表必须不同(参数个数不同、或类型不同、参数排列顺序不同等。)

方法的返回值类型可不同也可相同。

仅仅返回值类型不同不足以成为方法重载。

实现的理论

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐一匹配，以选择对应的方法，如果匹配失败，则编译器会报错。

点击查看代码

public static void main(String[] args) {
        // 方法调用 MyTests.sum(3, 5)
        int sum1 = MyTests.sum(3, 5);
        // 调用的是方法sum(int a ,double b,int c)
        double sum2 = MyTests.sum(13,20.8,19);
        System.out.println(sum1);
        System.out.println(sum2);

    }

    // 方法定义
    public static int sum(int a,int b){
        return a+b;
    }

    public static double sum(int a ,double b,int c){
        return a+b+c;
    }

方法的可变参数

JDK1.5开始，Java支持传递同类型的可变参数给方法。
在方法声明中，指定参数类型后加一个省略号(...)。
一个方法中只能定义一个可变参数，并且它必须是方法的最后一个参数，任何普通的参数必须在它之前申明。

点击查看代码

public static void main(String[] args) {
        double sum1 = sum(10, 20, 30);
        double sum2 = sum(10, 20.3, 34.5, 22.1);
        System.out.println(sum1);
        System.out.println(sum2);


    }

    // 重载方法 int... a 是一个可变参数
    public static double sum(int... a) {
        double sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];

        }
        return sum;
    }

    // 重载方法，double... b 可变参数必须是所有参数的最后
    public static double sum(int a, double... b) {
        double sum = a;
        for (int i = 0; i < b.length; i++) {
            sum += b[i];
        }

        return sum;
    }

方法-递归

自己调用自己的一个过程，形成递归。
理念就是使用简单的代码解决相似重复的逻辑。将复杂的逻辑简单化处理。

递归结构组成包含2部分：

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

递归体：什么时候需要调用自身方法。

点击查看代码

public static void main(String[] args) {
        int res = fn(5);
        System.out.println(res); // 120

    }

    // 递归函数-阶乘函数
    // 5！= 5*4*3*2*1
    public static int fn(int a) {
        // 递归头
        if (a == 1) {
            return 1;
        } else {
            // 递归体
            return a * fn(a - 1);
        }

    }

数组

定义

相同类型数据的有序集合。

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。

其中，每一个数据称作一个数组元素，每个数组元素都可以通过一个对应的下标来访问。

数组的元素通过索引访问，索引从0开始。数组长度array.length。

数组声明创建

数组的创建有2种方式

dataType[] arrayRefVar;,这种方式创建数组首选。

dataType arrayRefVar[];，这种方式创建数组效果一样，但是不建议使用。

完整的创建语法为：
dataType[] arrayRefVar = new dataType[arraySize]; 数组是引用类型，创建时通过关键字new操作符创建。

点击查看代码

public static void main(String[] args) {
        int[] numbers = new int[5];
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
        System.out.println(numbers.length);
        int sum = 0;
        for (int i = 0; i < numbers.length; i++) {
            sum+=numbers[i];
        }
        System.out.println(sum);
    }

数组的初始化赋值

数组的初始化有3种：

静态初始化

int[] a = {1,2,3}; 这种声明时就赋值，静态赋值。

动态初始化,申明的时候不赋值，在后续代码运行时动态给值。

int[] a = new int[3];
a[0] = 10;
a[1] = 11;
a[2] = 12;

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一旦分配空间，其中的元素也被按照实例变量的方式默认初始化。
默认初始化的值，参考数据类型，比如 Int数组的默认初始化为0,String类型的数组为null；

数组的四个基本特点

长度是确定的，数组一旦被创建，大小是不可变的。

其中的元素类型是相同的，不允许出现混合类型。

数组中的元素可以是任意类型，包括基本类型和引用类型。

数组变量属于引用类型，数组也被看作是一个对象，所以数组本身是保存在堆中的。

多维数组

多维数组可以看作是数组的数组，比如二维数组就是一个特殊的一维数组，二维数组中的每一个元素都是一个一维数组。
二维数组
int[][] a = new int[2][5];,看作是一个2行5列的数组。

Arrays类

数组的工具类java.util.Arrays
数组本身操作的方法有限，所以Api中提供了一个专门操作数组的类Arrays。
Arrays类中的方法都是静态的，一般使用的时候通过类名调用，不用new对象。

Arrays常用的方法：

数组赋值：fill方法。

数组排序：sort方法。

数组比较：equals,比较的是数组元素中的值。

数组查找：binarySearch方法对排序好的数组进行二分查找。

其他方法参考JDK帮助文档。

面向对象编程（OOP）

面向过程&面向对象

面向过程思想
- 步骤清晰简单，第一步做什么..，第二步做什么...
- 适合处理一些较为简单的问题。
面向对象思想
- 分类的思考模式，思考问题首先思考解决当前问题需要分哪些类，然后对类单独做思考，最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
宏观上，采用面向对象思维模式；微观上，采用面向过程的思考模式。

面向对象（Object Oriented Programming,OOP）

面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据。

现实中，先存在一个个具体对象，才有抽象的类。而在java编程世界中，是先有类，才有一个个对象。
类是一种抽象的数据类型，是对某一类事物整体描述和定义，用来表示某一类事物应该具备的属性特点和行为。
类中存在属性和行为（方法）。

面向对象三大特性：

封装
继承
多态

类与对象的创建

创建类

点击查看代码

/*
	定义了一个人的类，代表了人的共同特性和行为方法。
*/
public class Person {
    /*
    这些都是类的属性
    private String name;
    private int age;
    private double salary;
     */
    private String name;
    private int age;
    private double salary;

    /*
    类的方法行为：study 学习的行为
     */
    public static void study(){
        System.out.println("学习...");
    }
}

创建对象

使用new关键字创建对象

使用 new 关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及构造器的调用。

构造器也叫构造方法，实在创建对象的时候必须调用的，且构造器有2个特点：
- 1.必须和类的名字相同。
- 2.必须没有返回值，也不能写void。

点击查看代码

/*
	定义了一个人的类，代表了人的共同特性和行为方法。
*/
public class Person {
	// 无参构造器，不显示定义的话，系统也是默认存在的。
    public Person() {
    }
	// 定义一个有参构造
	public Person(String name){
        this.name = name;
    }

    /*
    这些都是类的属性
    private String name;
    private int age;
    private double salary;
     */
    private String name;
    private int age;
    private double salary;

    /*
    类的方法行为：study 学习的行为
     */
    public void study(){
        System.out.println("学习...");
    }
}

点击查看代码

public static void main(String[] args) {
		// 关键字 new 创建对象。
        Person person = new Person();
		// 调用对象的学习方法。
        person.study();

    }

构造方法详解

一个类即使什么都不写，系统也会存在一个无参数的构造方法。

创建对象时，使用new关键字，本质是在调用构造方法。

构造方法也是一个特殊的方法，所以也可以重载。

当一个类中定义了有参构造方法时，无参构造方法需要显示的定义出来。

构造方法的作用是用来初始化属性值。

三大特性-封装

程序设计时追求高内聚，低耦合。高内聚，程序内部的数据操作细节自己完成，不允许外部干涉，对外部隐藏;低耦合，仅暴露少量的方法给外部调用。
封装：通常是数据的隐藏，禁止直接操作数据，而是提供对外的接口来间接访问。
封装一般是对属性私有，提供 get/set方法访问操作。

点击查看代码

public class Student {

    // 类中属性私有。用关键字private修饰
    private String name;
    private int id;
    private String className;
    // 提供get/set方法访问和操作数据

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

三大特性-继承

java 中类之间是可以集成的，类的继承只能实现单继承，一个类只能继承一个类。
类与类中间存在的关系往往是什么是什么的关系，比如：student类与person类，student也是person。student类可继承Person。
继承的关键字是extend。

posted @ 2023-08-01 23:16 蔡剑波阅读(29) 评论(0) 收藏举报

刷新页面返回顶部

java 基础

注释

单行注释

多行注释

文档注释

标识符、关键字

标识符注意点

数据类型

分类

数据类型转换

变量

变量作用域

运算符

java程序结构-顺序结构

java程序结构-选择结构

if单选择结构

if双选择结构

if多选择结构

嵌套if结构

switch多选择结构

java程序结构-循环结构

while循环

do...while循环

for循环

增强for循环

java中方法

方法的定义和调用

方法定义

方法调用

方法的重载

方法的可变参数

方法-递归

数组

定义

数组声明创建

数组的初始化赋值

数组的四个基本特点

多维数组

Arrays类

面向对象编程（OOP）

面向过程&面向对象

面向对象（Object Oriented Programming,OOP）

类与对象的创建

三大特性-封装

三大特性-继承

公告