java语法和面向对象三大特性

**

Java语法和面向对象三大特性

**
Java语法基础
输入输出（Input/Output）：Java 中可以使用 Scanner 类来实现从控制台输入数据，使用 System.out.println() 来实现输出数据。

import java.util.Scanner;

public class InputOutputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个整数：");
        int num = scanner.nextInt();
        System.out.println("您输入的整数是：" + num);

        scanner.close();
    }
}

数组（Array）：Java 中数组是一种存储相同类型数据的数据结构，可以通过下标访问数组元素。

public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        for (int i = 0; i < arr.length; i++) {
            System.out.println("数组元素：" + arr[i]);
        }
    }
}

分支（Branching）：Java 中的分支语句包括 if-else 和 switch-case，用于根据条件执行不同的代码块。

public class BranchingExample {
    public static void main(String[] args) {
        int num = 10;

        if (num > 0) {
            System.out.println("正数");
        } else if (num < 0) {
            System.out.println("负数");
        } else {
            System.out.println("零");
        }
    }
}

循环（Loop）：Java 中的循环语句包括 for、while 和 do-while，用于重复执行一段代码块。

public class LoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("循环次数：" + i);
        }

        int j = 1;
        while (j <= 5) {
            System.out.println("循环次数：" + j);
            j++;
        }
    }
}

面向对象三大特性
封装（Encapsulation）：封装通过将数据和方法封装在类中，使用访问修饰符控制访问权限，实现数据隐藏和保护。

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;
    }
}

继承（Inheritance）：继承允许一个类继承另一个类的属性和方法，子类可以重写父类方法，实现代码重用和扩展。

public class Student extends Person {
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
}

多态（Polymorphism）：多态允许不同类的对象对同一消息做出不同的响应，包括方法重载和方法重写。

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪叫");
    }
}

public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵叫");
    }
}

以上是关于 Java### Java 语法和面向对象三大特性

Java 语法基础
输入输出（Input/Output）：Java 中可以使用 Scanner 类来实现用户输入，使用 System.out.println() 来实现输出。

import java.util.Scanner;

public class InputOutputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入你的名字：");
        String name = scanner.nextLine();
        
        System.out.println("你好，" + name + "！");
    }
}

数组（Array）：Java 中数组是一种存储相同类型数据的数据结构，可以通过下标访问数组元素。

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

分支（Branching）：Java 中的分支结构包括 if-else 和 switch-case 语句，用于根据条件执行不同的代码块。

public class BranchingExample {
    public static void main(String[] args) {
        int x = 10;
        
        if (x > 5) {
            System.out.println("x 大于 5");
        } else {
            System.out.println("x 不大于 5");
        }
    }
}

循环（Loop）：Java 中的循环结构包括 for、while 和 do-while 循环，用于重复执行代码块。

public class LoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("循环次数：" + i);
        }
    }
}

面向对象三大特性
封装（Encapsulation）：通过将数据私有化并提供公共方法来实现封装。

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

继承（Inheritance）：通过子类继承父类来实现继承，子类可以重写父类方法。

public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

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

多态（Polymorphism）：通过接口或父类引用指向子类对象来实现多态。

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();
        
        circle.draw();    // 输出：画一个圆形
        rectangle.draw(); // 输出：画一个矩形
    }
}