java编译基础————四个大类

 一 常量与变量

1.关键字与保留字

2.标识符与命名规范

3.变量的定义与赋值

4.常量

5..变量的类型转换

6.Scanner的使用

二.数据类型
1.整数数据类型
byte：大小：8位（1字节）取值范围：-128 到 127默认值为0

short：大小：16位（2字节）取值范围：-32,768 到 32,767默认值为0

int：大小：32位（4字节）取值范围：-2,147,483,648 到 2,147,483,647默认值为0

long：大小：64位（8字节）取值范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807默认值为0L（注意L后缀，表示long类型）

2.小数数据类型

float 单精度浮点数，存储容量4个字节，最大能够精确小数位为7或8位。小数后面必须加“f”或“F”。

double 双精度浮点数，存储容量8个字节，最大能够精确小数位位15或16位。
 

3.字符数据类型
char 字符类型，存储容量2个字节，有且仅能存储一个符号。数据必须使用单引号包括起来。比如'a' ' '

4.布尔数据类型
boolean：可以表示true或false默认值为false

三.运算符
1.算术运算符
1）不同的运算符在表达式中进行运算的先后次序

2）（）的优先级最高

3）*和/的优先级要大于+和-

2.关系运算符
1）关系表达式运算结果有两个：

            “真” ： 1

            “假” ： 0

2）C语言中，非零值表示“真”，零表示“假”。

3）优先级:前四个高于后两个，低于算术运算符

4）结合性：自左至右

3.逻辑运算符
1）C语言对逻辑表达式求解，并不是所有的运算符都被执行，只是在必须执行后面的运算才能求出表达式时，才执行其后的运算，否则将不执行后面的运算

2）优先级：！---- &&  ------   ||

3)结合性：&&    、 ||   自左向右   ！自右向左

4.条件运算符
1）用于连接3个运算对象，是C语言中唯一的一个三目运算符 

2）结合性：自右向左     

四.数组
数组是一种用于存储多个相同类型数据的数据结构                                                                                                 

1）获取数组的最值

import java.util.Arrays;

public class ArrayMinMax {

public static void main(String[] args) {

int[] array = {12, 36, 40, 15, 9, 20};

int min = array[0];

int max = array[0];

for (int i = 1; i < array.length; i++) {

if (array[i] > max) {

max = array[i];

}

if (array[i] < min) {

min = array[i];

}

}

System.out.println("Min: " + min);

System.out.println("Max: " + max);

}

}

2.数组排序算法

1）冒泡排序法

public class BubbleSortExample {
    public static void main(String[] args) {
        int[] array = {1,5,9,10,18,20,6,7};
        bubbleSort(array);
        for (int i : array) {
            System.out.println(i);
        }
    }
 
    public static void bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

2）选择排序法

public class SelectionSortExample {
    public static void main(String[] args) {
        int[] array = {9,8,7,6,5,4,3,2,1}; 
        selectionSort(array);
   
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
 
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
        
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
   
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

3）二分查找法

public class BinarySearch {
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
 
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (array[mid] == target) {
                return mid; 
            } else if (array[mid] < target) {
                left = mid + 1; 
            } else {
                right = mid - 1; 
            }
        }
        return -1;
    }
 
    public static void main(String[] args) {
        int[] sortedArray = {1,5,9,7,11,13,3,15,17,19};
        int target = 13;
        int index = binarySearch(sortedArray, target);
        if (index != -1) {
            System.out.println("Element found at index " + index);
        } else {
            System.out.println("Element not found");
        }
    }
}

面向对象程序设计  ----------五个大类

一.面向对象的概念  

1.什么是面向对象

面向对象就是：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。

2.面向对象的特性

面向对象的特性包括封装、继承和多态。
封装（Encapsulation）：封装是将数据和操作相关联并组合成一个单独的实体，对外部隐藏内部的细节。通过封装，可以保护数据的安全性和完整性，同时提供了对数据和操作的可控性。
继承（Inheritance）：继承是指一个类从另一个类中派生出来，继承的类称为子类或派生类，被继承的类称为父类或基类。继承可以实现代码的重用，子类可以继承父类的属性和方法，并且可以在此基础上进行扩展和修改。
多态（Polymorphism）：多态是指同一类型的对象在不同的情况下可以表现出不同的行为。在面向对象中，多态可以通过函数重载、函数重写和接口实现来实现。多态性使得程序具有更高的灵活性和可扩展性，可以根据不同的需求来选择合适的行为。
这些特性使得面向对象编程具有更好的可维护性、可复用性和可扩展性，能够更好地组织和管理复杂的程序。
 

3.类和对象

类和对象

1）类的定义：类是对象的模板，描述了一组具有相同属性和行为的对象。
2）对象的定义：类与对象，对象是类的实例，具有自己特点的具体事物。
3）类与对象的关系：类是对象的模板，对象是类的具体实例。类是对象的模板，对象是类的实例，类不能直接使用，需要通过创建对象来使用。
4）类与对象的属性与方法：类由属性和方法构成，属性表示对象的特征，方法表示对象的行为。

二.面向对象编程

1.类的定义

2.对象的创建与使用

3.成员变量默认值

4.对象内存分析

5.匿名对象

三.构造方法

2.构造方法的使用

3.构造方法的重载

构造函数

1）构造函数的定义：构造函数是一种特殊的方法，它在创建对象时被调用，并用于初始化对象的成员变量。构造函数通常与类的名称相同，没有返回类型，且可以有一些参数来初始化对象的属性。
2）构造函数的主要目的：是为了确保对象在创建时具有合适的初始状态。它可以执行任何必要的操作，例如分配内存、初始化变量或执行其他初始化代码。

四.this关键字

1.this关键字介绍

2.this关键字的使用

this关键字主要有三个应用

 (1)this调用本类中的属性，也就是类中的成员变量；
 (2)this调用本类中的其他方法；
 (3)this调用本类中的其他构造方法，调用时要放在构造方法的首行

五.static关键字

1.静态变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。类变量：使用 static 关键字修饰的成员变量。

2.静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。类方法：使用 static 关键字修饰的成员方法，习惯称为静态方法

静态方法调用的注意事项：

• 静态方法可以直接访问类变量和静态方法。

• 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

• 静态方法中，不能使用 this 关键字。

3.静态代码块

静态代码块：定义在成员位置，使用 static 修饰的代码块{ }。位置：类中方法外。执行：随着类的加载而执行且执行一次，优先于 main 方法和构造方法的执行。