【JavaSE】复习总结

🎁个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章
🔍系列专栏：【Java】内容概括

一、Java输入输出

1.控制台输出

public static void main(String[] args) {
        System.out.println("hello");
    }

2.控制台输入

使用Scnner类,需要导入import java.util.Scanner;

//创建一个Scanner对象scanner,并将其与标准输入流System.in关联起来
 Scanner scanner = new Scanner(System.in);
 System.out.println("name:");
//调用Scanner对象的nextLine()方法，读取输入的内容，并储存到变量name中
 String name = scanner.nextLine();

二、类和对象

Java是面向对象的编程语言，类是对事物的抽象描述，对象是类的实例。

1.类的定义

使用class关键字定义类,类中包含成员变量和成员方法

public class Person {
    String name;
    int age;
    public void action(){
        System.out.println("play");
    }
}

2.对象的创建和使用

static修饰的静态变量只能有一个
对象的创建也就是实例化

public class Person {
    String name;
    int age;
    public void action(){
        System.out.println("play");
    }
    public static void main(String[] args) {
    //Person:类名
    //person:变量，用来引用new Person()创建出来的对象
        Person person = new Person();
        person.name = "baby";
        person.age = 20;
        person.action();
    }
}

3.构造方法

构造方法用于对象的初始化，与类名同名，无返回值类型。

• 如果没有显式定义构造方法，编译器会提供一个默认的无参构造方法；
• 如果定义了构造方法，默认无参构造方法会被覆盖

public class Student {
    String name;
    int age;
    //有参构造方法
    public Student(String name,int age){
    //把构造方法的参数name的值赋给类的成员变量name
        this.name = name;
        this.age = age;
    }
}

4.this 关键字

this表示当前对象的引用

• 可用于区分成员变量和局部变量（名称冲突时）
• 也可以在构造方法中调用其他构造方法，this(参数列表)，必须位于构造方法第一行

public class Car {
    String brand;//品牌
    int price;//价格
    public Car(String brand,int price){
        this.brand = brand;
        this.price = price;
    }
    public Car(String brand){
        //调用有参构造方法
        this(brand,10000);
    }
    public void display(){
        System.out.println(this.brand+this.price);
    }

    public static void main(String[] args) {
        Car car = new Car("宝马");
        car.display();
    }
}

5.包

Package 是Java中一个组织 类 的方式，用于防止类名冲突和提高代码可持续性
自定义包：

6.封装

封装是面向对象的三大特性之一，将类的属性私有化（用 private 修饰），提供公共的getter和setter方法分别来访问和修改属性，因此内部实现细节，提高代码安全性和可维护性。

public class User {
    private String username;
    private String password;
    //读取用户名
    public String getUsername(){
        return username;
    }
    //修改用户名
    public void setUsername(String username){
        this.username = username;
    }
    //读取密码
    public String getPassword(){
        return password;
    }
    //修改密码
    public void setPassword(String password){
        this.password = password;
    }
}

三、继承

继承是面向对象的三大特性之一，允许一个类（子类）继承另一个类（父类）的属性和方法，实现代码复用。Java中类只支持单继承，但可以多层继承。

1.继承的实现

使用extends关键字实现继承

public class Animal {
    String name;

    public void eat() {
        System.out.println(name + "eating");
    }
}

public class Dog extends Animal{
    public void bark(){
        System.out.println(name+"汪汪汪~");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "大黄";
        dog.eat();
        dog.bark();
    }
}

2.方法重写（Override）

子类可以重写父类的方法，要求方法名，参数列表，返回值类型相同（或者子类的返回值类型是父类的子类型），访问权限不能比父类严格。

public class Person {
    public void study(){
        System.out.println("读");
    }
}

public class Personadd extends Person{
    //Ctrl+O
    @Override
    public void study() {
        System.out.println("写");
    }
}

3.super 关键字

super 用于访问父类的属性，方法和构造方法。在子类构造方法中，super()或super(参数列表)用于调用父类的构造方法，且必须位于子类构造方法的第一行。

public class Father {
    String familyName ="张";
    public Father(){
        System.out.println("父类无参构造方法");
    }
    public void showFamilyname(){
        System.out.println("家族姓氏"+familyName);
    }
}

public class Son extends Father{
    public Son(){
        //调用父类的无参构造方法
        super();
    }
    public void showInfo(){
        //调用父类的showFamilyname方法
        super.showFamilyname();
        //访问父类的familyname变量
        System.out.println("子类中访问父类姓氏"+super.familyName);
    }
}

三、多态

多态是面向对象的三大特性之一，指同一个行为有多种不同表现形式。多态的实现需要满足：继承，方法重写，父类引用指向子类。

public class Shape {
    public void draw(){
        System.out.println("绘制图形");
    }
}

public class Circle extends Shape{
    @Override
    public void draw() {
         System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape{
    @Override
    public void draw() {
       System.out.println("绘制矩形");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        //父类的引用指向子类对象
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.draw();//绘制圆形
        shape2.draw();//绘制矩形
    }
}

【核心知识点总结】

• 继承：子类复用父类的结构，同时可扩展或修改父类行为（如重写 draw() ）。

• 方法重写：子类用与父类“方法名、参数列表、返回值”一致的方法，替换父类的实现，实现定制化逻辑。

• 多态：父类引用可以指向子类对象，调用方法时，会根据“实际对象的类型”执行对应的（子类重写的）方法，让代码更灵活、可扩展。

四、抽象类和接口

抽象类和接口是实现抽象和多态的重要手段

1.抽象类

• 用abstract 修饰，不能实例化，用于定义一组相关子类的共同行为和属性，是子类的“模板”；
• 可含抽象方法（无方法体，子类必须实现所有的抽象方法）和普通方法
• 子类要先构造父类的构造方法

public abstract class Animaladd{
    protected String name;//protected修饰，子类可直接访问
    public abstract void makeSound();//抽象方法，无方法体
    //普通成员方法，设置mz
    public void setName(String name){
        this.name = name;
    }
}

public class Dogadd extends Animaladd{
    //重写抽象父类的makeSound()方法,否则会报错
     @Override
     public void makeSound() {
         System.out.println(name+"汪汪汪~");
     }
 }

public class Testadd {
    public static void main(String[] args) {
        //创建Dog对象，子类可实例化，抽象父类不行,不能直接new
        Dogadd dogadd = new Dogadd();
        //调用继承的setName()方法设置名字
        dogadd.setName("旺财");
        //调用重写的makeSound()方法
        dogadd.makeSound();
    }
}

2.接口

• 使用interface 关键字定义接口，JDK 8之后支持默认方法，静态方法；
• 类用implements实现接口，需实现所有的抽象方法，一个类可实现多个接口；
• 接口间可通过extends多继承

interface IFlyable {
    //抽象方法
    void fly();
    default void land(){
        System.out.println("降落");
    }
}

public class Bird implements IFlyable{
    @Override
    public void fly() {
        System.out.println("飞翔");
    }
}