当前位置： 首页 > article >正文

java 基础语法速成

article 2024/12/2 18:32:57

java 基础语法速成

彩笔稍微整理了一下，速成用，小登期末别看这个，会挂科的。。。

JDBC，内存管理，文件IO，算法等都没写。

参考了狂神说java

文章目录

  • java 基础语法速成
    • 0. 一些概念
    • 1. 流程互动
    • 2. 方法
    • 3. 面向对象
      • 1. 构造器，继承，重写
      • 2. 多态
      • 3. 接口
    • 4. 反射

0. 一些概念

常用快捷键

alt+insert 快速添加getter和setter
Ctrl+D 复制当前行到下一行

第一个程序

当前文件夹上面的路径改成cmd，然后回车开命令行

在命令行输入下面命令

javac hello.java 编译生成class文件

java hello 运行hello.class

//hello.java
//下面类名要跟文件名一致
public class hello{
    //main方法
	public static void main(String[] args){
		System.out.println("Hello World!");
	}
}

标识符和关键字

java所有的组成部分名字，类名，变量名以及方法名。

48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。

3）3个特殊直接量：true、false、null。

标识符注意点：1. 首字符可以是字母，美元符，下划线。

  1. 不能使用关键字作为变量名或方法名。
  2. 标识符是大小写敏感的。
String $money="64";//初始化
System.out.println($money);

数据类型

java的数据类型主要分为两大类：基本类型，引用类型。
基本数据类型包括：数值类型（byte,short,int,long,float,double,char(占2字节)），boolean类型（占1位，其值只有true和false两个）
引用数据类型包括：类，接口，数组
float num5=50.1F;//float类型要加F
long num3=30L;//long类型要在数字后加L
byte num4=20;
int num99=010;//八进制
int num66=0x10;//十六进制
int k=100_000_000;//JDK7新特性，数字之间可以用下划线分割
double s=1.234E-2;//1.234*(10^-2)
double ll=99.99;
char name='请';
//字符串String不是关键字，而是类
String namea="秦疆";
//布尔值
boolean b=true;
//Boolean类
Boolean flag=true;//Boolean类的实例，而不是boolean类型
if(flag instanceof Boolean){//判断是不是Boolean的实例
    System.out.println("yes");
}
//数组声明
int[]  nums;
int nums2[];
//数组创建(默认初始化)
nums=new int[10];
或者：int[] nums=new int[10];
//静态初始化
int[] a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};
Class[] paramTypes=new Class[]{String.class,String.class};//元素为Class类的数组
//动态初始化
int[] a=new int[2];
a[0]=1;
a[1]=2;
//数组赋值
for(int i=0;i<nums.length;i++)
{//nums.length自动读取数组长度
    nums[i]=i;
}
for(int i:nums){
    //nums.for加回车就能生成类似这个
    //nums是一个数组，i是数组的每一个元素
    System.out.print(i+" ");
}

注意：浮点数会有精度问题，所以如果需要运算的话一般用BigDecimal数学工具类

输入输出

Scanner对象的方法包括nextByte(),nextShoret(),nextInt(),nextLong(),nextFloat(),nextDouble()
    可以通过next()与nextLine()方法获取字符串，读取前我们一般用hasNext()与hasNextLine()判断是否还有输入数据
next()
1. 一定要读取到有效字符后才可以结束输入
2. 对有效字符前面遇到空白，next()方法会自动去掉
3. 只有输入有效字符后才将后面输入的空白（空格）作为分隔符或结束符
4. next()不能得到带有空格的字符串

nextLine()
1. 以Enter位结束
2. 可以获取空白

import java.util.Scanner;
import java.util.InputMismatchException;
//计算圆面积
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        final double PI = 3.1415926;
        // 提示用户输入半径
        System.out.print("请输入圆的半径（整数）：");
        try {
            // 检查是否有整数输入
            if (input.hasNextInt()) {
                int r = input.nextInt();
                // 检查半径是否为非负数
                if (r >= 0) {
                    // 计算面积并格式化输出
                    double area = PI * Math.pow(r, 2);
                    System.out.printf("圆的面积是：%.2f%n", area);
                } else {
                    System.out.println("半径不能为负数！");
                }
            } else {
                System.out.println("请输入一个有效的整数！");
            }
        } catch (InputMismatchException e) {
            // 捕获并处理非整数输入异常
            System.out.println("输入错误，请输入一个整数！");
            // 清除输入错误标记
            input.next(); // 消耗掉错误的输入
        } finally {
            // 关闭Scanner以释放资源
            input.close();
        }
    }
}

1. 流程互动

if...else if...else
while(){}
do{}while()
for (int item : numbers) {
    System.out.println("Count is:" + item);
}
char grade='c';
switch(grade){
    case 'a':System.out.println("niu");break;
        case 'b':System.out.println("liang");break;
        case 'c':System.out.println("xing");break;
        case 'd':System.out.println("buxing");break;
        case 'e':System.out.println("ji");break;
    default:System.out.println("shen");break;
}

2. 方法

命令行传参

package com.kuang.method
public static void main(String[] args) {
        int a=1,b=2;
  		for(int i=0;i<args.length;i++){
             System.out.println(args[i]);
        }
}
//命令行先在路径为包里面javac demotwo.java
//然后在路径为src里java com.kuang.method.demotwo
this is kuang

可变参数

public class Demo4{
    public static void main(String[] args){
        demott demo4=new demott();
        demo4.test(1,61,62,63,64,65);
    }
    public void test(int x,int... i){
        for(int m:i){
            System.out.print(m+" ");
        }
    }
}

方法重载

public int add(int a,int b){
        return a+b;
}
public double add(double a,double b){
    return a+b;
}

3. 面向对象

1. 构造器，继承，重写

注意：父类权限，子类不能重写static，final，private方法

package com.jk.cc;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.io.IOException;
import java.lang.reflect.*;
import java.lang.Boolean;
public class cc1test {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Child child1 = new Child("123");
        child1.say("hello");
        // 输出：
        //父类有参构造：123
        //Child constructor with message called
        //666
        //hello
    }

}
class Parent {
    String message;//成员变量
    // 父类构造器
    Parent() {
        System.out.println("Parent constructor called");
    }

    Parent(String message) {
        this.message=message;
        System.out.println("父类有参构造："+this.message);
    }
    public void say(String name){
        System.out.println("666");
    }
}

class Child extends Parent {
    // 子类构造器，调用父类的无参构造器（隐式调用，如果父类有无参构造器）
    // 或者显式调用：super();

    Child() {
        // 隐式调用Parent()
        System.out.println("Child constructor called");
    }

    // 子类构造器，显式调用父类的带参构造器
    Child(String message) {
        super(message); // 子类调用父类构造器必须在第一行
        //显式调用Parent(String message)
        System.out.println("Child constructor with message called");
        //调用父类方法
        super.say("123");
    }
    @Override
    public void say(String name){//子类重写父类方法
        System.out.println(name);
    }
}

2. 多态

多态（向上转型，向下转型）

1. 多态是方法的多态，属性没有多态
2. 父类和子类有联系
3. 存在条件：有继承关系，方法需要重写，父类引用指向子类对象
4. 子类转换为父类可能丢失本来方法
    
//向上转型，即父类的引用指向子类的对象
/*
编译类型看左边，运行类型看右边
可以调用父类的所有成员（需遵守访问权限）
不能调用子类的特有成员
运行效果看子类的具体实现
*/
父类类型 引用名 = new 子类类型();
//右侧创建一个子类对象，把它当作父类看待使用

//向下转型（高转低）,即一个已经向上转型的子类对象，将父类引用转为子类引用
/*
特点：
只能强制转换父类的引用，不能强制转换父类的对象
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后，可以调用子类类型中所有的成员
*/
语法
子类类型 引用名 = (子类类型) 父类引用;
//用强制类型转换的格式，将父类引用类型转为子类引用类型
//这里的子类可以是实现类，父类可以是接口
if(animal instanceof  Cat){
    Cat c=(Cat)animal;
    System.out.println(c.name);
}

//演示代码
public class demott {


    public static void main(String[] args) {
        //向上转型（自动类型转换）
		//程序在编译阶段只知道 p1 是 Person 类型
		//程序在运行的时候才知道堆中实际的对象是 Student 类型
        Person p1 = new Student();

        //调用的是 Student 的 mission
        //程序在编译时 p1 被编译器看作 Person 类型
		//因此编译阶段只能调用 Person 类型中定义的方法
		//在编译阶段，p1 引用绑定的是 Person 类型中定义的 mission 方法（静态绑定）
		//程序在运行的时候，堆中的对象实际是一个 Student 类型，而 Student 类已经重写了 mission 方法
		//因此程序在运行阶段对象中绑定的方法是 Student 类中的 mission 方法（动态绑定）
        p1.mission();
        
        //向下转型
        Student s1 = (Student)p1;

        //调用的是 Student 的 score
        s1.score();
    }

}
 class Person {
    public   void mission() {
        System.out.println("人要好好活着！");
    }
}
class Student extends Person {
    public   void mission() {
        System.out.println("学生要好好学习！");
    }
    public void score() {
        System.out.println("学生得到好成绩！");
    }
}
class Teacher extends Person {

    public  void mission() {
        System.out.println("老师要好好教书！");
    }
    public void salary() {
        System.out.prinjavatln("老师得到高工资！");
    }
}

3. 接口

1. 接口可以多继承
2. 只有规范
3. 接口中所有定义都是抽象的public abstract
4. 类可以实现接口
5. 必须重写接口中的方法
6. Java语言中,接口是不能创建对象的。（据说）
7. 接口不能被实例化。
8. 接口没有构造方法和静态代码块
9. 父类方法跟接口方法冲突时，执行父类方法
10. 接口里的静态方法可直接用`接口名.方法名()`调用

// 定义第一个接口
interface Swimmer {
    void swim();
}
// 定义第二个接口
interface Flyer {
    void fly();
}
// 定义一个类来实现上述两个接口
class SuperCreature implements Swimmer, Flyer {
    // 实现Swimmer接口中的方法
    @Override
    public void swim() {
        System.out.println("Swimming...");
    }
    // 实现Flyer接口中的方法
    @Override
    public void fly() {
        System.out.println("Flying...");
    }
    // 可以定义类自己的方法
    public void eat() {
        System.out.println("Eating...");
    }
}
// 测试类
public class TestInterfaces {
    public static void main(String[] args) {
        // 创建SuperCreature对象
        SuperCreature creature = new SuperCreature();
        // 调用实现的方法
        creature.swim(); // 输出：Swimming...
        creature.fly();  // 输出：Flying...
        // 调用类自己的方法
        creature.eat();  // 输出：Eating...
    }
}

4. 反射

Class对象类的获取

import java.lang.Class;
//1.根据类名：类名.class
Class userClass =User.class;
//2.根据对象：对象.getClass()
User user=new User();
Class ac=user.getClass();
//3.根据全限定类名：Class.forname("全路径名")
Class ac=Class.forName("com.example.demo1.User");
//4.通过类加载器获取Class对象：
//ClassLoader.getSystemClassLoader().loadClass("com.example.demo1.User");
ClassLoader clsload=ClassLoader.getSystemClassLoader();
Class ac2=clsload.loadClass("com.example.demo1.User");

获取成员变量

import java.lang.Class;
import java.lang.reflect.Field;
//Class类中用于获取成员变量的方法
Field[] getFields()://返回所有 公共 成员变量对象的数组
Field[] getDeclaredFields()://返回所有成员变量对象的数组
Field getField(String name)://返回单个公共成员变量对象
Field getDeclaredField(String name)://返回单个成员变量对象
    
//Field 类中用于创建对象的方法
void set(Object obj,Object value):赋值
Object get(Object obj)获取值。

//Class类中用于获取构造方法的方法
Constructor<?>[] getConstructors(): 返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors(): 返回所有构造方法对象的数组
Constructor<T>[] getConstructor(Class<?>... parameterTypes): 返回单个公共构造方法对象
Constructor<T>[] getDeclaredConstructor(Class<?>... parameterTypes):
    //返回单个构造方法对象

//Constructor类中用于创建对象的方法
T newInstance(Object... initargs): 根据指定的构造方法创建对象
setAccessible(boolean flag): 设置为true，表示取消访问检查

        
//Class类中用于获取成员方法的方法
Method[] getMethods():返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods():返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>... parameterTypes) :返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>... parameterTypes):返回单个成员方法对象

//Method类中用于创建对象的方法
Object invoke(Object obj, Object... args):
运行方法
参数一:用obj对象调用该方法
参数二:调用方法的传递的参数(如果没有就不写)
返回值:方法的返回值(如果没有就不写)

参考代码

Class ac1=Class.forName("java.lang.Runtime");
Method exec1=ac1.getMethod("exec", String.class);
Method getRuntime1=ac1.getMethod("getRuntime");
Object runtimeObject=getRuntime1.invoke(ac1);
exec1.invoke(runtimeObject, "calc.exe");

http://www.kler.cn/a/418806.html

相关文章：

  • unique_ptr
  • mapstruct DTO转换使用
  • golang用errgroup的一个小小坑
  • C#VB.NET开发整体一键国际化显示
  • Flutter：页面滚动
  • 十一、快速入门go语言之接口和反射
  • 【阅读笔记】Android广播的处理流程
  • Vue 2.0-＞3.0学习笔记（Vue 3 （四）- Composition API 的优势）
  • 第29天 MCU入门
  • C#基础教程
  • OD E卷 - 实现 【虚拟理财游戏】
  • 【青牛科技】电动工具调速控制电路芯片GS069介绍
  • 安装Fcitx5输入框架和输入法自动部署脚本(来自Mark24)-Ubuntu通用
  • D82【python 接口自动化学习】- pytest基础用法
  • 多线程篇-8--线程安全（死锁，常用保障安全的方法，安全容器，原子类，Fork/Join框架等）
  • windows下安装node.js和pnpm
  • YOLO 标注工具 AutoLabel 支持 win mac linux
  • 【Electron学习笔记（三）】Electron的主进程和渲染进程
  • 【论文复现】从零开始搭建图像去雾神经网络
  • 【软考速通笔记】系统架构设计师⑧——系统质量属性与架构评估
  • 14 - Java 面向对象（中级）
  • SqlServer REVERSE字符串值的逆序排序函数
  • 框架学习07 - SpringMVC 其他功能实现
  • Cisco WebEx 数据平台：统一 Trino、Pinot、Iceberg 及 Kyuubi，探索 Apache Doris 在 Cisco 的改造实践
  • 线性表-链式描述（C++）
  • 【联表查询】.NET开源 ORM 框架 SqlSugar 系列