Java基础：自学java之路

Ainke

已于 2023-09-02 10:30:41 修改

阅读量120

点赞数

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

于 2022-10-29 21:23:08 首次发布

本文链接：https://blog.csdn.net/ainwa/article/details/127590686

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

1.引言
2. java 基本语法
3.面向对象
4异常处理
5总结

1.引言

Java是一种面向对象的编程语言，由Sun Microsystems公司于1995年推出。它的主要特点是跨平台性、面向对象、健壮性、安全性和可靠性。

2. java 基本语法

2.1变量和数据类型

Java中的变量可以存储各种不同类型的数据，例如整数、浮点数、字符和布尔值等。Java的数据类型分为基本数据类型和引用数据类型。

// 声明和初始化整数变量
int age = 25;
// 声明和初始化浮点数变量
double weight = 65.5;
// 声明和初始化字符变量
char grade = 'A';
// 声明和初始化布尔变量
boolean isStudent = true;

2.2运算符

Java支持各种常见的运算符，包括算术运算符、关系运算符、逻辑运算符和位运算符等。

// 算术运算符
int a = 10;
int b = 5;
int sum = a + b; // 加法
int difference = a - b; // 减法
int product = a * b; // 乘法
int quotient = a / b; // 除法
int remainder = a % b; // 求余

// 关系运算符
boolean isEqual = (a == b); // 等于
boolean isNotEqual = (a != b); // 不等于
boolean isGreater = (a > b); // 大于
boolean isLess = (a < b); // 小于
boolean isGreaterOrEqual = (a >= b); // 大于等于
boolean isLessOrEqual = (a <= b); // 小于等于

// 逻辑运算符
boolean result1 = (a > b) && (a < 20); // 与
boolean result2 = (a > b) || (a < 20); // 或
boolean result3 = !(a > b); // 非

// 位运算符
int c = 7; // 二进制表示为0111
int d = 3; // 二进制表示为0011
int bitwiseAnd = c & d; // 按位与，结果为0011，即3
int bitwiseOr = c | d; // 按位或，结果为0111，即7
int bitwiseXor = c ^ d; // 按位异或，结果为0100，即4
int bitwiseNot = ~c; // 按位取反，结果为1000，即-8
int leftShift = c << 1; // 左移1位，结果为1110，即14
int rightShift = c >> 1; // 右移1位，结果为0011，即3

2.3控制流程

Java提供了多种控制流程语句，如条件语句（if-else、switch-case）、循环语句（for、while、do-while）和跳转语句（break、continue、return）等。

// 条件语句 - if-else
int score = 85;
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("不及格");
}

// 循环语句 - for循环
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

// 跳转语句 - break和continue
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // 跳出循环
    }
    if (i == 3) {
        continue; // 跳过本次循环，继续下一次循环
    }
    System.out.println(i);
}

// 跳转语句 - return
public int sum(int a, int b) {
    return a + b; // 返回结果并结束方法
}

2.4数组

数组是Java中一种常见的数据结构，用于存储多个相同类型的数据。Java中的数组可以是一维的，也可以是多维的。

// 一维数组
int[] numbers = new int[5]; // 声明并初始化长度为5的整型数组
numbers[0] = 1; // 给数组元素赋值
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]); // 遍历数组并输出元素
}

// 多维数组
int[][] matrix = new int[3][3]; // 声明并初始化3x3的二维整型数组
matrix[0][0] = 1; // 给数组元素赋值
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
matrix[2][0] = 7;
matrix[2][1] = 8;
matrix[2][2] = 9;
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " "); // 遍历数组并输出元素
    }
    System.out.println();
}

3.面向对象

3.1类与对象

Java是一种面向对象的编程语言，类是Java中的基本构建单元。通过类，可以创建对象并调用对象的方法。

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

Person person = new Person("John", 25);
person.sayHello();

3.2继承与多态

Java支持继承和多态的特性，通过继承可以实现类的层次结构，通过多态可以实现动态绑定和方法的重写。

public class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

Animal animal = new Dog();
animal.makeSound(); // 输出 "Dog barks"

3.3封装与访问控制

Java通过封装可以隐藏对象的实现细节，提供公共的接口供其他对象使用。访问控制关键字（public、private、protected）用于控制对类、属性和方法的访问权限。

public class Person {
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

Person person = new Person();
person.setName("John");
System.out.println(person.getName()); // 输出 "John"

3.4接口与抽象类

接口是一种规范，定义了一组方法的签名。抽象类是一种不能被实例化的类，用于定义共享的属性和方法。

public interface Shape {
    double getArea();
    double getPerimeter();
}

public abstract class AbstractShape implements Shape {
    protected String color;
    
    public AbstractShape(String color) {
        this.color = color;
    }
    
    public abstract double getArea();
    public abstract double getPerimeter();
}

public class Circle extends AbstractShape {
    private double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

Circle circle = new Circle("Red", 5);
System.out.println(circle.getArea()); // 输出 "78.54"

4异常处理

4.1异常的分类

Java中的异常分为可查异常（checked exception）和不可查异常（unchecked exception）。可查异常在编译期检查，需要进行处理；不可查异常在运行期抛出，可以不处理。

4.2异常的分类

try {
    int result = divide(10, 0);
    System.out.println(result);
} catch(ArithmeticException e) {
    System.out.println("除数不能为0");
} finally {
    System.out.println("执行finally块");
}

public int divide(int a, int b) {
    return a / b;
}

4.3 自定义异常

Java允许自定义异常类，通过继承Exception类或其子类来实现。

public class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

try {
    throw new MyException("自定义异常");
} catch(MyException e) {
    System.out.println(e.getMessage());
}