java基础知识梳理与基本语法（有例子）

草宣

已于 2023-11-28 00:09:34 修改

阅读量2.1k

点赞数 45

文章标签： java 开发语言

于 2023-11-27 23:32:08 首次发布

本文链接：https://blog.csdn.net/2301_79640217/article/details/134535352

版权

本文概述了Java的基础知识，包括语言特点（可移植性、面向对象和强类型），基本语法（变量、数据类型、运算符、控制流和异常处理），以及面向对象编程的类、对象、封装、继承和多态。还介绍了Java类库、数组、方法、类与对象的概念和示例。

摘要由CSDN通过智能技术生成

一、Java的基础知识

1. Java的特点

- 可移植性：Java程序可以在不同的平台上运行，只需编写一次并在不同的操作系统上运行。
- 面向对象：Java是一种面向对象的编程语言，提供了类、对象和继承等面向对象特性。
- 强类型：Java是一种强类型语言，要求变量在使用之前必须声明，并且要严格匹配类型。

2. Java的基本语法

- 变量和数据类型：Java中的变量必须先声明后使用，并且需要指定数据类型。常见的数据类型有整型、浮点型、字符型等。
- 运算符：Java支持各种运算符，包括算术运算符、赋值运算符、逻辑运算符等。
- 控制流语句：Java提供了条件语句（if-else语句、switch语句）和循环语句（for循环、while循环）来控制程序的流程。

3. 面向对象编程

- 类和对象：Java是一种面向对象的语言，核心概念是类和对象。类是对象的模板，对象是类的实例。
- 封装：通过访问修饰符（public、private、protected）来限制对类成员的访问。
- 继承：通过继承可以实现类之间的关系，子类可以继承父类的属性和方法，并且可以重写父类的方法。
- 多态：多态是指同一操作作用于不同的对象上，可以产生不同的结果。通过重写和重载来实现多态。

4. 异常处理

- Java提供了异常处理机制，通过try-catch-finally块来处理异常。
- 可以根据具体的异常类型来捕获和处理异常，并采取相应的措施。
- 异常处理可以提高程序的可靠性和稳定性。

5. 常用的Java类库

- Java提供了丰富的类库，包括输入输出、网络操作、数据结构、日期时间等功能。
- 常用的类库有Java.io、Java.net、Java.util等，可以根据需求灵活运用。

二、基本语法

1、变量、数据类型与输出：在Java中，变量必须先声明后使用，并且需要指定数据类型,以下列举了几个常用的数据类型。

//整形
int age = 20;
//浮点型
double weight = 42.5;
//字符串类型
char name = '宁';

//输出
System.outprintln(age);//输出内容后换行
System.out.print(weight);//输出内容后不换行
System.out.printf(“%d,%f,%s”，age,weight,name);
//按指定格式输出，不换行，%d，%f称为格式标识符
//%d--整型，%f--浮点型，%s--字符串

2、运算符：Java支持各种运算符，包括算术运算符、赋值运算符、逻辑运算符等

①算数运算符

int a = 10;
int b = 5;
int result;

result = a + b; // 加法运算
System.out.println("a + b = " + result);

result = a - b; // 减法运算
System.out.println("a - b = " + result);

// *乘 /除 %取余，同理

②逻辑运算符

boolean x = true;
boolean y = false;

boolean result = x && y; // 逻辑与运算
System.out.println("x && y : " + result);

result = x || y; // 逻辑或运算
System.out.println("x || y : " + result);

result = !x; // 逻辑非运算
System.out.println("!x : " + result);

③赋值运算符

int a = 10;
int b = 5;
int result;

result = a; // 简单赋值
System.out.println("result = " + result);

result += b; // 加法赋值，相当于 result = result + b;
System.out.println("result += b : " + result);

result -= b; // 减法赋值，相当于 result = result - b;
System.out.println("result -= b : " + result);

// *乘 /除 %取余，同理

3、条件语句

①if语句

int age = 18;
if (age >= 18) {
    System.out.println("成年人");
} else {
    System.out.println("未成年人");
}

②if-else语句

int score = 80;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

③Switch语句

int dayOfWeek = 3;
String dayName;
switch (dayOfWeek) {
    case 1:
        dayName = "星期一";
        break;
    case 2:
        dayName = "星期二";
        break;
    case 3:
        dayName = "星期三";
        break;
    case 4:
        dayName = "星期四";
        break;
    case 5:
        dayName = "星期五";
        break;
    default:
        dayName = "周末";
        break;
}
System.out.println(dayName);

4、循环语句

①for循环

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

②while语句

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

5、数组的声明和初始化

int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[3];
names[0] = "Tom";
names[1] = "Jerry";
names[2] = "Alice";

以上都是基础，接下来的例子会更详细些。

6、方法

方法:为完成某个功能而组合在一起的语句，一次定义，多次调用。先定义方法，再调用。方法分为有参构造方法和无参构造方法，以下是方法的基本结构。

下面来看一个例子：这里注意最后一个if循环是num1>num2，而不是其他，因为通过前两次比较num3为最大了，这时只需要比较num1和num2即可。

public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		System.out.print("请输入三个数：");
		int x=scan.nextInt();
		int y=scan.nextInt();
		int z=scan.nextInt();
		System.out.printf("排序前为：%d %d %d\n",x,y,z);
		displaySortedNum(x,y,z);//调用方法
	}
//构造有参方法
	public static void displaySortedNum(int num1,int num2,int num3) {
		if (num1>num2) {
			int temp=num1;
			num1=num2;
			num2=temp;//调换两个数一定要借用一个容器
		}
		if (num2>num3) {
			int temp=num2;
			num2=num3;
			num3=temp;
		}
		if (num1>num2) {
			int temp=num1;
			num1=num2;
			num2=temp;
		}
		System.out.printf("排序后为：%d %d %d",num1,num2,num3);
	}

7、类与对象

①类的定义与对象的创建

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 + " and I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("John", 20);
        person1.sayHello();
        
        Person person2 = new Person("Alice", 25);
        person2.sayHello();
    }
}

在上面的例子中，我们定义了一个名为Person的类，它有两个私有属性name和age，以及一个公有的构造方法和一个公有的sayHello方法。构造方法用于创建Person对象时初始化name和age属性，而sayHello方法用于输出个人信息。

在Main类的main方法中，我们创建了两个Person对象person1和person2，并通过调用sayHello方法来输出它们的个人信息。

运行上述代码，输出如下：

Hello, my name is John and I am 20 years old.
Hello, my name is Alice and I am 25 years old.

②get和set方法

另外，通过使用get和set方法，我们可以控制对类的私有属性的访问，增加了代码的封装性和灵活性。同时，get和set方法还可以在需要时添加数据验证或其他逻辑。以下是get和set方法的例子：

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

在上面的例子中，我们定义了一个名为Person的类，它有两个私有属性name和age。为了访问这些私有属性，我们使用了公有的get和set方法。get方法用于获取属性的值，而set方法用于设置属性的值。

在Main类的main方法中，我们创建了一个Person对象person，并使用set方法设置其name和age属性的值，然后使用get方法获取并输出这些属性的值。

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(20);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

③构造方法

通过构造方法，我们可以在创建对象时方便地初始化其属性，使得对象的创建和属性的初始化过程更加简洁和便捷。同时，如果需要，我们还可以创建多个构造方法，以提供不同的对象初始化方式。

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

在上面的例子中，我们定义了一个名为Person的类，它有两个私有属性name和age。构造方法是与类同名的特殊方法，用于在创建对象时初始化对象的属性。在Person类中，我们定义了一个构造方法，该构造方法有两个参数name和age，用于初始化对象的name和age属性。

在Main类的main方法中，我们创建了一个Person对象person并传入name和age参数来调用构造方法，从而初始化person对象的属性。

public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 20);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

④类的继承

通过继承，可以添加和重写自己的方法。这样可以实现代码的重用和扩展性，使得类之间的关系更加灵活和易于维护。

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println(getName() + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Bobby");
        dog.eat();
        dog.bark();
    }
}

在上面的例子中，我们定义了一个基类Animal和一个派生类Dog。Animal类有一个私有属性name和一个eat()方法，Dog类继承了Animal类，并添加了一个自己的方法bark()。

在Main类的main方法中，我们创建了一个Dog对象dog，并调用了它继承自Animal类的eat()方法和自己的bark()方法。

8、抽象类与接口

①抽象类

通过抽象类，我们可以将一些通用的属性和方法定义在抽象类中，然后由具体的子类去实现具体的逻辑。这样可以保证代码的一致性和可扩展性，使得类之间的关系更加清晰和易于维护。

public abstract class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public abstract void eat();
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + " is eating.");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + " is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Bobby");
        Cat cat = new Cat("Kitty");
        
        dog.eat();
        cat.eat();
    }
}

在上面的例子中，我们定义了一个抽象类Animal，它有一个私有属性name和一个抽象方法eat()。抽象方法没有具体的实现，需要在具体的子类中实现。

Dog类和Cat类继承了Animal类，并实现了eat()方法。在Main类的main方法中，我们创建了一个Dog对象和一个Cat对象，并调用它们的eat()方法。

运行上述代码，输出如下：

Bobby is eating.
Kitty is eating.

②接口

通过接口，我们可以定义一组方法的规范，然后由具体的类去实现这些方法。这样可以实现代码的灵活性和可替换性，使得不同的类可以根据自己的需要去实现相同的接口，从而实现多态性和代码的扩展性。

public interface Animal {
    public String getName();
    public void eat();
}

public class Dog implements Animal {
    private String name;
    
    public Dog(String name) {
        this.name = name;
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + " is eating.");
    }
}

public class Cat implements Animal {
    private String name;
    
    public Cat(String name) {
        this.name = name;
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + " is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Bobby");
        Cat cat = new Cat("Kitty");
        
        dog.eat();
        cat.eat();
    }
}

通过接口，我们定义了Animal接口，并在其中声明了getName()和eat()方法。Dog类和Cat类分别实现了Animal接口，并实现了接口中定义的方法。

在Main类的main方法中，我们创建了一个Dog对象和一个Cat对象，并调用它们的eat()方法。

运行上述代码，输出如下：