JAVA入门

java 入门

psvm 直接输出main作为程序的入口

public static void main(String[] args) {

}

sout 将想要的内容输出到主程序

System.out.println("我爱Java");

// 单行注释

/*
        多行注释
 */

/**
 * 文档注释
 */

变量的简单使用

 // 变量的声明
        // 定义一个年龄的变量, 名字（标识符）叫age
        // java中不能重复定义变量
        int age;
        // 同时可以定义多个变量
        int a, b;
        // 变量的赋值
        age = 18;
        age = 32;
        age = 40 + 18;

        // 变量的定义和赋值可以定义在同一行
        int age1 = 19;
        int c = 10, d = 20;
        int e, f = 30; // 这里是定义的 e并没有赋值

数据类型	名称
基本数据类型	数值、字符、布尔
引用数据类型	类、接口、数组

// 整数类型
        byte a = 10; //范围【-128 ~ 127】
        short b = 20; // 正负30000
        int c = 30; // 正负21亿
        long d = 40; // 很大很大，如果表述范围超过了int的范围，就需要在末尾加上 L
        long d_ = 12345678910L; // 其中，这个L 大小写都可

        // 浮点类型
        float aa = 3.14f; //使用float表示小数，后面一定要加f
        double bb = 3.1415926;

        // 字符类型
        char aaa = 'a'; // 必须用单引号引起来，且是一个字符

        // 布尔类型
        boolean aaaa = true; //布尔类型只有 true 或 false

运算符

        byte a = 12;
        System.out.println(a++ + 13); // 如果 ++ 放变量后面就是先运算后加1
        // 结果25
        System.out.println(a + 13);
        // 结果26

条件判断

        byte score = 67;
        if(score >= 90)
        {
            System.out.println("学生成绩为优秀");
        }
        else if(score < 90 && score >= 80)
        {
            System.out.println("该学生的成绩为良好");
        }
        else
        {
            System.out.println("该学成成绩为一般");

        }

while 循环

        int num = 1, sum = 0;
        while(num <= 5)
        {
            sum += num;
            num ++;
            System.out.println(sum);
        }

for 循环

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

方法的定义与重载

    public static int sumNum(int num_1, int num_2)
    {
        return  num_1 + num_2;
    }

    public static void main(String[] args) {
        // main其实就是一种方法，其中 public static 就是修饰符 void 是返回类型 main是方法名
        // String[] args 是形参列表
        int a = 12, b = 14;
        System.out.println(sumNum(a, b));

数组的创建与赋值

        int[] arr; // 创建一个 int类型的数组，命名为 arr
        arr = new int[4];// 创建的时候要给定数组一个长度，这里长度取4

        /*
        上述可合写为
        int[] arr = new int[4];
         */

        // 数组的赋值
        for(int i = 0; i < 4; i++)
        {
            arr[i] = i + 1;
        }
        for(int i = 0; i < 4; i++)
        {
            System.out.println(arr[i]);
        }

增强 for循环

        // 增强 for循环
        for (int i : arr)
        {
            System.out.println(i);
        }

类的编写，创建，和使用

创建一个类，同时定义其属性和方法

package com.cjk.test04;

/*
定义一个人的类
 */

public class Person {
    // 特性-属性
    String name; // 姓名
    int age; // 年龄
    double height; // 身高

    // 行为-方法
    public void study() {
        System.out.println("大丈夫生于天地间，岂能郁郁久居人下");
    }
}

调用这个类，创建对象，并使用它

package com.cjk.test04;

/*
测试类
 */

public class Test4 {
    public static void main(String[] args) {
        // 对Person 类进行创建，创建一个Person对象，名字叫 p1
        Person p1 = new Person();
        // 对 p1的属性进行赋值
        p1.name = "Atta";
        p1.age = 21;
        p1.height = 180.88;
        // 对属性进行读取
        System.out.println("\n姓名:"+p1.name+"\n年龄:"+p1.age+"\n身高:"+p1.height);
        p1.study();

    }
}

类主要的成员分为三种：属性，方法，构造器（构造方法）
构造器是一种特殊的方法，对象在初始化时候自动调用这种方法
JAVA 通过new关键字来调用调用构造器，从而返回该类的实例
构造器没有返回类型，

package com.cjk.test04;

/*
定义一个人的类
 */

public class Person {
    //...前面一样的省略

    // 显示定义空构造器
    public Person(){
        System.out.println("调用空构造器");
    }
}

调用

// 创建一个 person对象， 其中 Person()就是一个空的构造方法
// new 关键字对方法进行调用，构造器作用：在底层中创建对象以后，"*进行初始化操作*"
// 构造器对对象进行了初始化操作，同时将对象的地址返回给了 p2
// 尽量保证空构造器的存在
Person p2 = new Person();

构造器重载

    // 构造器重载
    public Person(int a, String b, double c){
        age = a;
        name = b;
        height = c;
    }

Person p2 = new Person();
p2.age = 20;
p2.name = "Atta";
p2.height = 180.88;
Person p3 = new Person(12, "Btta", 160.01);
System.out.println(p2.name);
System.out.println(p3.name);

如果构造器中的参数的名字和属性名字相同，会采用就近原则，可能会导致错误

如果重名，且想要赋值，那么就需要在属性的变量的前面加上 this

public Person(int age, String name, double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }

如果一个类中有空构造器，那么系统不会分配给你默认空的构造器（也就是说你直接Person()无效）

IDEA中快速使用构造器的快捷键: Alt + Insert

构造器可分为：无参构造器，有参构造器

封装

创建一个 Boy类，其中年龄为私有的，只能在类内进行访问

public class Boy {
    // 属性
    private int age;
    String name;
    public Boy(){
    }

    // 给 age提供一个赋值的方法
    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }

}

// 创建一个对象
Boy b = new Boy();
b.setAge(18);
b.name = "小张";
System.out.println(b.getAge());

当然了，代码这样子写可能体现不出封装的意义，but:
这样子，封装的意义显而易见了

public void setAge(int age){
        if(age > 30)
        {
            this.age = 18;
        }
        else{
            this.age = age;
        }

    }

程序追求：“高内聚，低耦合”
高内聚：类内操作细节自己完成，不允许外部干涉
低耦合：仅仅对外部暴露少量的方法用于使用

封装性的设计思想：
隐藏对象的复杂性，只对外部公开简单的接口，便于外界调用，从而提高系统的扩展性、可维护性
提高程序的安全性，通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。

set get 方法快捷键 insert + alt

继承

首先定义一个 Person类，同时定义其属性和方法

public class Person {
    // 父类中公共的属性进行一个定义
    private int age;
    private String name;
    private double height;

    // 父类的方法定义
    public void eat(){
        System.out.println("人可以吃饭");
    }

    public  void sleep(){
        System.out.println("人可以睡觉");
    }



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

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }
}

然后 Student类通过 extends来继承 Person的属性和方法，同时 Student只需要定义额外的属性和方法即可

public class Student extends Person{ // 子类 Student继承父类 Person
    // 定义额外的，扩展的属性和方法
    private String cls;

    String getCls(){
        return cls;
    }
    void setCls(String cls){
        this.cls = cls;
    }

    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("AttaSayyid");
        stu1.setAge(21);
        stu1.setHeight(188.88);
        stu1.setCls("人工智能 1 班");
        System.out.println(stu1.getCls());
    }


}

继承的好处

提高代码的复用性
便于代码的扩展
为了多态的使用

方法的重写

什么是方法的重写：发生在子类和父类中，当子类对父类的方法不满意的时候，要对父类的方法进行重写
方法的重写有严格的格式要求：子类的方法名字和父类必须要一致，参数列表（个数，类型，顺序），也要和父类一致

重载和重写的方法：
重载：在同一个类中，方法名相同，形参列表不同，多个方法构成了重载。
重写：在不同的类中，子类对父类提供的方法不满意的时候，对父类的方法进行重写。

父类

public class Person {
    public void eat()
    {
        System.out.println("人可以吃饭");
    }
}

子类

public class Student extends Person{
    public void eat(){
        System.out.println("我喜欢吃安卓食堂");
    }

    public static void main(String[] args) {
        Student stu = new Student();
        stu.eat();
    }
}
// 输出结果：我喜欢吃安卓食堂

注意，重载和重写毫无关系

多态

什么是多态：通俗的讲就是多种形态，具体点就是，去完整某个行为，当不同的对象去完成时会产生不同的状态，同一种行为，不同的子类呈现出来的状态是不同的。
注意：多态和属性无关，多态只的是方法的多态，而不是属性的多态。。。

我们定义了父类 Animal，然后定义不同的子类 Dog Cat 继承父类

拆分写法

Animal a = new Animal("小白");
Cat c = new Cat();
a = c;

合成写法

public class Test {
    public static void main(String[] args) {
        Girl g = new Girl("小晴");
        Animal a = new Dog("小白");
        g.playWith(a);
    }
}

多态的三要素：继承，重写，父类的引用指向子类对象
多态的优点：提高代码的扩展性

异常的处理

public class Test01 {
    public static void main(String[] args) {
        int num1 = 4;
        int num2 = 0;
        try{
            System.out.println(num1/num2);
        }catch (Exception ex){
            System.out.println("对不起，您的程序出现了错误");
            System.out.println(ex.toString());
        }
        finally {
            System.out.println("无论代码是否出现异常，这个代码都执行");
        }
    }
}

异常处理

直接自行处理
使用 throw抛出异常，然后通过throws 声明此处可能会出现异常，将异常抛给调用此处的函数的异常，让外部处理此异常

public class Test02 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;
        try{
            divide(num1, num2);
        }
        catch (Exception e){
            System.out.println("除数不能为0");
        }

        System.out.println("123");
    }

    public static void divide(int num1, int num2) throws Exception{
        if(num2 == 0)
        {

            throw new Exception();

        }
        else{
            System.out.println(num1 / num2);
        }

    }
}

集合

相比于数组，集合的优点
数组的长度固定，一旦定义，就无法修改
数组中元素的增加，删除效率低
数组中元素的实际个数无法获取

简单的集合实例

public class Test01 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList();

        // 增加元素
        arr.add("aaa");
        arr.add("bbb");
        arr.add("ccc");
        arr.add("ddd");
        System.out.println(arr);

        // 删除元素
        arr.remove("bbb");
        System.out.println(arr);

        // 修改元素
        arr.set(0, "eee");
        System.out.println(arr);
        // 查看元素

        System.out.println(arr.get(2));

        // 遍历集合
        for(int i = 0;i < arr.size();i ++)
        {
            System.out.println(arr.get(i));
        }
    }
}

posted @ 2025-12-10 14:59 AttaSayyid 阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

AttaSayyid