JAVA编程基础

m0_74772323

已于 2024-04-15 00:22:54 修改

阅读量1k

点赞数 30

文章标签： java 开发语言

于 2024-03-31 18:03:30 首次发布

本文链接：https://blog.csdn.net/m0_74772323/article/details/137200752

版权

导图

一、java概论

1、Java语言发展史

1990年年末，Sun公司预料嵌入式系统将在未来家电器领域大显身手。于是成立一个由詹姆斯·高斯林领导的“Green计划”，准备为下一代智能家电编写一个通用操作系统。推出一种全新的语言Oak（橡树，Java的前身）。詹姆斯·高斯林也被誉为“Java语言之父”。

在 Java语言的发展历程中， Java 被分成3个版本。
Java SE：定位在个人计算机上的应用。
Java EE:定位在服务端的应用。
Java ME：定位在消费性电子产品的应用。
其中,随着塞班(Symbian)系统的淘汰, Java ME 也随之沦为历史的尘埃。

2、Java语言特点

1、简单性

继承c和c++语言的优点，摒弃了c和c++语言中较难的知识和易发生程序错误的地方，取消#include等预处理功能，取消了struct，typedef等关键字，取消了指针，多重继承，goto等危险的语法，取消了操作符重载，取消了手动内存管理，并提供了自动的垃圾回收机制，大大的简化了程序员的资源释放管理工作。

2、面向对象

很多资料中会将C++列为半面向对象半面向过程的语言，因为其为了兼容C，保留了很多面向过程的成分，使其自身成为仅带有类的C语言。而 Java 是一种完全面向对象的序设计语言，它具备抽象、封装、继承和多态等特性，支持类之间的单继承和接口之间的多承，还支持类与接口之间的实现机制和全面动态绑定。面向对象是 Java 最重要的特一，具有代码扩展，代码复用等功能，可以使得应用程序的开发变得更加简单易用、易组易扩展等。

3.跨平台性

Java是跨平台的，他自带的Java虚拟机可以实现跨平台性。Java源程序代码经过生成与平台无关的二进制代码，即字节码文件（class.文件）。可被JVM中的Java解释器解释成所子啊具体平台上的机器指令，可以装在有JVM的任何平台上运行，从而实现Java语言与平台无关

4、可移植性

java的可移植性来源于其跨平台性，java作为一个虚拟机具有cpu可移植性，java作为一种虚拟的操作系统和图形用户界面具有操作系统的可移植。

5、安全性

屏蔽了指针，避免非法操作内存，禁止程序越界访问

6、健壮性

安全检查记者，异常处理，自动垃圾收集

7、编译和解释性

一种解释执行的高级编程语言，先将Java源程序编译生成与机器无关的字节码

8、高性能

Java是一种先编译后解释的语言，所以它不如全编泽性语言快。低是、有些情况下性长度能是很要紧的，为了支持这些情况，Java设计者制作了“及时”(Just-In-Time,JIT)缩泽程作系序，它能在运行时把Java字节码翻译成特定CPU的机器代码，即实现了全编泽、Java字节码格式设计时考虑到这些T编译程序的需要，所以生成机器代码的过程相当简单，它产生相当好的代码。事实上，Java运行速度随者JIT编译器技术的发展越来越接近C 、与那些解释型的高级脚本语言相比，Java语言的高性能的.

9、动态性

Java语言的设计目标之一是适应于动态变化的环境，Java的程序需要类能够动态地被载入运行环境，也可以通过网络载入所需要的类，程序可以自动进行版本升级。

10、多线程

允许一个应用程序同时对多个的线程，用于支持程序中的事务并发和多任务处理。多线程的主要优点是可以在很大程度上提高程序的执行效率，且每个线程不占用内存，他们共享一个共享内存区域。

11、分布性

Java语言是一种支持分布式计算的网络编程语言，既支持各种层次的网络连核，又可
以通过Socket3类等支持可靠的Stream进行网络连接，从而支持Internet p应用的开发，在
基本的Java应用编程接口中有一个网络应用编程接口(java.net),它提供了用于网络应用
编程的类库，包括URL(统一资源定位符)，URLConnection、Socket、ServerSocket等以支持
Java的分布式环境下的网络编程。

二、

1、变量

在 Java 中，变量是一种用于存储数据值的占位符。变量是 Java 编程中基本的数据类型，程序中几乎所有的操作都需要用到变量。程序运行的时候，变量中存储的数据可以发生改变。Java 变量分为 基本类型 和 引用类型 两种。

1、关键字与保留字

2、定义与赋值

在 Java 中定义变量需要指定变量的类型和名称

int a;

a = 1;//int a = 10;也可在定义同时赋值

3、常量

常量指的是在程序中固定不变的值，是不能改变的数据。在Java中，常量包括整型常量、浮点型常量、布尔常量、字符常量。

1.整型常量：整数类型的数据：主要有如下4种形式：

二进制：由数字0和1组成的数字序列。在JDK7.0中允许使用字面值来表示二进制数，前面要以0B或0b开头，为了和十进制的数进行区分，如0b01101100、0B10110101。

八进制：以0开头并且其后0~7范围内（包括0和7）的整数组成的数字序列

十进制：由数字0~9范围内（包括0和9）的整数组成的数字序列，

十六进制：以0x或者0X开头并且其后由0~9，A~F（包括0和9，A和F）组成的数字序列，

2.浮点型常量：数学中用到的小数，分为双精度浮点数（double）和单精度浮点数(float)两种类型。双精度浮点数后面以D或d结尾，单精度浮点数后面以F或f结尾。

3.字符型常量：用单引号引起来的一个字符，如 'e'、E'。需要注意的是，Java 字符串常量值中的单引号和双引号不可混用。

4.字符串常量：用于表示一串连续的字符，一个字符串常量要用双引号引起来。

5.布尔常量：布尔常量是只有两个值，即 false（假）和 true（真）。

6.null常量：null常量只有一个值null，表示对象的引用为空。

2、数据类型

1、基础数据类型

数值型

整数类型

byte，short，int，long

byte是一种基本数据类型，表示8位的有符号整数。共有256个可能的值。byte类型通常用于节省内存，或在处理二进制数据时使用，例如读取文件或处理图像数据等。

short是一种基本数据类型，表示16位的有符号整数。，共有65536个可能的值。short类型通常用于需要节省内存但又超出了 byte类型范围的情况，但在实际开发中较少使用，因为大多 int类型已经足够满足需求，而且现代计算机的内存通常足够大，

int是一种基本数据类型，表示32位的有符号整数，共有约21亿个可能的值。int类型是Java中最常用的整数类型，通常用于存储整数数据，进行算术运算和索引数组等操作。

long是一种基本数据类型，表示64位的有符号整数。共有约19个十的18次方个可能的值。long类型通常用于需要存储较大整数值的情况，或者需要处理较大整数范围的算术运算。

浮点类型

float，double

float是一种基本数据类型，表示单精度浮点数。可以使用字母f或F作为后缀。float类型通常用于存储需要较大范围但不需要高精度的浮点数数据。例如，科学计算、工程应用、图形处理等场景常常会使用float类型。

注意：由于单精度的精度有限，不适合用于要求高精度的计算。

double是一种基本数据类型，表示双精度浮点数。double类型的取值范围大约是从 4.9E-324 到 1.8E+308（包括负数），并且可以使用字母d或D作为后缀。double类型通常用于需要更高精度的浮点数数据。与float相比，double类型提供了更大的精度和范围

因此常用于科学计算、工程应用、金融计算等需要高精度的场景。

字符型

char

一种基本数据类型，用于表示单个字符。从'\u0000'到'\ufff'表示字母，数组，符合等包括ASCII字符，Unicode字符以及特殊字符

布尔型

boolean

一种基本数据类型，用来表示布尔值，即true 或者false，常用于条件判断和逻辑运算

2、引用数据类型

类（class）

类（Class）是一种引用数据类型，用于描述对象的属性和行为。类是面向对象编程的核心概念之一，它提供了一种组织代码和数据的方式，使得程序能够更加模块化、可维护和可扩展。

类由属性（字段）和方法组成。属性表示类的状态或特征，而方法表示类的行为或功能。通过创建类的对象（也称为实例），可以使用类中定义的属性和方法。

Java中的类组成部分：

类名（Class Name）：类的名称，用于在程序中引用该类。
属性（Fields）：类的成员变量，用于存储对象的状态或特征。
方法（Methods）：类的成员函数，用于定义对象的行为或功能。
构造方法（Constructors）：用于创建对象时进行初始化操作的特殊方法。
访问修饰符（Access Modifiers）：用于限制类、属性和方法的访问权限，如public、private、protected等。
其他成员（Static Fields/Methods、Final Fields等）：类中可能包含静态属性、静态方法、常量等其他成员。
通过定义类，可以创建对象的模板，从而实现代码的重用和扩展。在Java中，类是面向对象编程的基础，几乎所有的程序需要类来构造

接口（iterface）

一种引用数据类型，一个抽象类型，是抽象方法的集合，接口通常以interface来声明。

一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但它们属于不同的概念

接口指明了一个类必须要做什么和不能做什么，相当于类的蓝图。

是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

3、运算符和表达式

1、算术运算符：

执行基本的数学运算，如加法、减法、乘法、除法等。

+：加法
-：减法
*：乘法
/：除法
%：取模（取余数）

n++（返回值，再+n);n--反之

++n（先+1，再返回值);++n反之

2、赋值运算符：

用于给变量赋值。

=：简单赋值
+=、-=、*=、/=、%=等：复合赋值运算

3、关系运算符

>：大于
<：小于
>=：大于等于
<=：小于等于

==：等于
!=：不等于

4、逻辑运算符

&:与运算

|：或

^：异或运算

&&：逻辑与
||：逻辑或
!：逻辑非

5、位运算符

<<：左移
>>：带符号右移
>>>：无符号右移

&：按位与
|：按位或
^：按位异或
~：按位取反

运算符的优先级：从高到低

括号 ()
正负号＋、-
一元运算符 +, -, ++, --, !
乘除取模运算符 *, /, %
加减运算符 +, -
移位运算符 <<, >>, >>>
关系运算符 <, <=, >, >=, instanceof
比较运算符 ==, !=
位与运算符 &
位异或运算符 ^
位或运算符 |
逻辑与运算符 &&
逻辑或运算符 ||
条件运算符 ? ：
赋值运算符=

6、三元运算符

条件表达？表达式1：表达式2

为true执行1，否则执行2

4、循环

1、for

for (表达式1; 表达式2; 表达式3)
{
语句;
}

2、 while

while（循环控制表达式）
{
语句序列
}

3、do while

do
{
语句序列
}while（循环控制表达式）;

4、break和continue

退出循环流程

5、数组

1、引用初始化数组：

int a[]={1,2,3}

int a[10];
int a[]{1,2,3}

2、索引

又称下标

索引的目的在于提高查询效率

3、遍历

for (int i = 0; i < numbers.length; i++) {
                        System.out.println(numbers[i]);

                }

4、排序

1、冒泡法:

相邻两个比较较大下沉，较小上冒；

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
 
        System.out.println("排序前数组：");
        printArray(array);
 
        bubbleSort(array);
 
        System.out.println("\n排序后数组：");
        printArray(array);
    }
 
    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换array[j]和array[j+1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
 
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

2、选择排序法

一组选出最大或最小和第一个位置的数交换，再从剩下的数中找最大或最小，直到n-1个元素（倒数第2个数）和第n个元素（最后一个数）比较。

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、二分法

又称折半查找法，每次找最中间的值，通过大小比较关系，从左还是右查询

模板：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int l = 0, r = 1000000000;
        int res = 0;
        while (l <= r) {
            int mid = (l + r) >> 1;
            if (check(mid)) {
                res = mid;
                l = mid + 1;
            }else {
                r = mid - 1;
            }
        }
    }

    private static boolean check(int mid) {
        // TODO Auto-generated method stub
        return false;
    }
}

5、二维数组

第一种表达：
数据类型[][] 数组名 = new数据类型[行的个数][列的个数];
int[][] xx= new int[3][4]; 表示有三行，每行有四个数据

第二表达：
数据类型[][] 数组名 = new int[行的个数][];

int[][] xx= new int[3][];
第二种方式和第一种类似，只是数组中每行元素的长度未知。

第三种表达：
数据类型[][] 数组名= {{第0},{第1},...,{第个n}};
int[][] xx= {{1,2},{3,4,5,6},{7,8,9}};
上面的二维数组arr中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}。

6 Arrays工具类

直接用Arrays.可以调用

常用以下：

构造方法：

构造方法是用来创建对象时初始化对象的特殊方法。它与类名相同，没有返回类型。构造方法用于设置对象的初始状态。

//Teach.java

public class Teacher{
	private String name;
	private int age;
	private double salary;
	
	//自定义有参构造函数
	public Teacher(String _name,int _age) {
		name=_name;
		age=_age;
	}

	//private成员变量的赋值、取值
	public void setSalary(double _salary) {	
		salary=_salary;
	}
	
	public String getName() {
		return name;
	}
	
	public int getAge() {
		return age;
	}
	
	public Double getSalary() {
		return salary;
	}
	
	public void show() {
		
		System.out.println("name:"+name+"\nage:"+age+"\nsalary:"+salary);
		
	}
	

}

this关键字：

this关键字用于引用当前对象。在构造方法或者方法中，可以使用this来区分成员变量和局部变量。同时，this也可以用于调用本类的其他构造方法。

public class MyClass {
    private int value;

    public void setValue(int value) {
        this.value = value; // 使用 this 引用实例变量
    }
}

static关键字：

static表示静态的，可以用来修饰变量、方法和代码块。静态变量属于类，而非对象，它们在类加载时初始化，并且只被初始化一次。静态方法可以通过类名直接调用，无需创建对象。

demo：

public class Sample {
    // 静态变量
    public static int count = 0;
    // 构造函数，每次创建实例时count增加
    public Sample() {
        count++;
    }
    // 静态方法
    public static void showCount() {
        System.out.println("当前实例数量：" + count);
    }
    public static void main(String[] args) {
        // 不需要创建实例即可调用静态方法
        showCount();  // 输出：当前实例数量：0
        // 创建两个实例
        new Sample();
        new Sample();
        showCount();  // 输出：当前实例数量：2
    }
}

封装：

把数据和操作都藏在一个小盒子里，不让外面的人随便看和碰。这样，只有我们知道怎么操作它，别人就只能通过我们给的小门进去看看或者动动。

如下：

public class A{
    private int age;

    //提供一个返回年龄的方法
    public int getAge(){
        return age;
    }

    //提供一个处理年龄误差的方法
    public void setAge(int age){
        if(age<80){
            age=18;
        }else{
            this.age = age;
        }
    }
}


public static void main(String[] args){

    A a = new A;
    a.getAge(81);
system.uot.println(a.setAge);

age的属性，由于加了一个private，访问就会受限，age的数值便都不会报错。

继承：

继承是面向对象编程的三大特性之一，它允许我们创建一个新的类（称为子类或派生类），继承一个已存在的类（称为父类或基类）的属性和方法。子类可以继承父类的属性和方法，也可以添加自己的属性和方法。

基本格式：

class 子类名 extends 父类名{
...
}

继承的实现：

class Person {
public Person(){
System.out.println("【Person父类】一个新的Person父类实例化对象产生了") ;
}
}
class Student extends Person {  // Student是子类
public Student(){ //构造方法
System.out.println("【Student子类】一个新的Student实例化对象产生了。") ;
}
}
public class StringDemo {
public static void main(String args[]){
new Student() ;  // 实例化子类对象
}
}

super关键字：

super关键字用于在子类中调用父类的属性和方法。当子类覆盖了父类的方法时，可以使用super来调用父类被覆盖的方法。

class Parent {  
    int number;  
  
    // 父类的构造方法  
    Parent(int number) {  
        this.number = number;  
    }  
}  
  
class Child extends Parent {  
    String name;  
  
    // 子类的构造方法，通过super关键字调用父类的构造方法  
    Child(int number, String name) {  
        super(number);  // 调用父类的构造方法，并传递number参数  
        this.name = name;  
    }  
}  
  
public class Test {  
    public static void main(String[] args) {  
        Child child = new Child(10, "Alice");  // 创建Child对象，并传递参数给父类和子类的构造方法  
        System.out.println("Number: " + child.number);  // 输出 "Number: 10"  
        System.out.println("Name: " + child.name);      // 输出 "Name: Alice"  
    }  
}

通过child的构造中使用super（number），明确调用parent类的带有一个整数参数的构造方法。

final关键字：

final可以用来修饰类、方法和变量。被final修饰的类不能被继承，被final修饰的方法不能被覆盖，被final修饰的变量是常量，其值不能被修改。

Object类：

Object类是Java中所有类的根类，任何类都是Object类的子类。Object类定义了一些基本的方法，如toString()、equals()、hashCode()等，这些方法可以被所有类继承和使用。

public class Person {
    ...
}
//上面和下面是等价的
public class Person extends Object {
    ...

多态：

多态是面向对象编程的三大特性之一，它表示同一个方法调用可以有不同的执行效果。多态的实现主要依赖于方法的重写和对象的类型转换。

定义一个父类，再定义一个子类（继承父类）

package test.xing;

class Father{
    protected int age;
    public Father(){
        age = 40;
    }

    void eat(){
        System.out.println("父亲在吃饭");
    }
}
class Child extends Father{
    protected int age;
    public Child(){
        age = 18;
    }

    void eat(){
        System.out.println("孩子在吃饭");
    }
    void play(){
        System.out.println("孩子在看电视");
    }
}

public class TestPolymorphic {
    public static void main(String[] args) {
        Father c = new Child();
        c.eat();
        //c.play();
        System.out.println("年龄："+c.age );

    }

}

抽象：

抽象是面向对象编程的基本概念之一，它允许我们定义抽象类和抽象方法。抽象类不能被实例化，只能被继承。抽象方法没有方法体，只有方法签名，子类必须实现抽象父类中的所有抽象方法。

接口：

接口是一种特殊的抽象类型，它只包含抽象方法的声明，不包含方法的实现。接口可以被类实现，实现接口的类必须提供接口中所有方法的具体实现。接口是实现多重继承的一种手段，通过接口，一个类可以实现多个接口，从而拥有多个类型。

public interface Electronic {
    // 常量
    String LED = "LED";

    // 抽象方法
    int getElectricityUse();

    // 静态方法
    static boolean isEnergyEfficient(String electtronicType) {
        return electtronicType.equals(LED);
    }

    // 默认方法
    default void printDescription() {
        System.out.println("电子");
    }
}