java简易笔记一篇入门

重返太空

已于 2022-04-18 08:17:00 修改

阅读量286

点赞数 1

分类专栏： x语言基础文章标签： java 开发语言学习

于 2022-04-17 22:45:30 首次发布

本文链接：https://blog.csdn.net/qq_40927195/article/details/124197272

版权

x语言基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

🍭 不要焦虑也不要放弃，每天进步一点点 🍭

学前必看

本文面向的是对 java 只想做一个基本了解的同学，比如暂时不搞开发的脚本小子，如果需要深入学习，不建议观看，看完本文可以掌握 java hello world 编写和各语言通用的流程控制函数和忽略不计的面向对象知识

java是一种面向对象的编程语言，有很多特定的工具类/函数，方便不同情景的快速编程，使用的开发工具是 IntelliJ IDEA
参考视频教程：狂神的java基础

java 基础

java helloworld

新建 HelloWorld.java 文件(环境安装略) 本文使用 SDK 版本为1.8

public class HelloWorld {
    public static void main(String[] args){
        System.out.print("hello world!");
    }
}

① java 是严格大小写的语言，Test 和 test 是两个东西

② 类名要与文件名一致

java 是编译型语言，首先需将 HelloWorld.java 文件编译成 HelloWorld.class 文件再执行

PS C:\java_lession> javac .\HelloWorld.java
PS C:\java_lession> java HelloWorld
hello world!

在这里插入图片描述

class 文件是字节码文件，介于 java 类文件和机器码之间的一种文件，然后由 JVM 来解释执行

定义变量

java 是强类型语言，需要先定义数据类型，然后定义名称，再赋值，像php、python等不用预先定义，即可使用

//定义变量为String字符串类型,变量名为test,值为 this is a test
String test = "this is a test";

变量命名时只能以字母、$ 美元符、或 _ 下划线开头

数据类型

整数

byte:占 1个字节  范围:-128-127
short:占 2个字节  范围:-32768-32767
int:占 4个字节  范围:-2147483648-2147483647
long:占 8个字节  范围:-9223372036854775808-9223372036854775807
//long num = 10L; long类型要在数字后面加个"L"来标识

浮点类型(小数)

float:占 4个字节  //float num = 1.1F; 需加"F"来标识
double:占 8个字节
//double精度高，有效数字16位，float精度7位

最好避免使用浮点数进行比较，如果超出范围，在定义时没有报错，但是存储时数据已经有损失

在这里插入图片描述

字符类型

char:占 2个字节  //只能定义一个字符,且必须用单引号包裹
char a = '网';
char a = 'A';

char 类型能表示的数据十分有限，而字符串我们是通过String类来定义，是类而不是数据类型

在定义时，一旦类型确定，会在内存开辟相应大小的空间来存放数据，尽量选择合适的类型来节省空间

boolean:true or false 只占一位

除了以上8种基本数据类型，其它的叫做引用数据类型

关于字节的科普

位(bit):存储数据的最小单位，0 或 1 占一位，简写为 b

字节(Byte):8 位为一个字节，可以表示0-255，在少数系统中不是 8 位

因为我们交流不能使用 01010 字符串，所以要使用编码，来使 01 字符串和字母或汉字对应，而能表示人类语言的一个最小单位，也就是数据处理的基本单位，或许可以称为字节

比如 ascii 编码，收录了 128 个字符，常见字母和常见符号，用一个字节即可表示所有

进制

java 中不同进制数据表示方法

int i1 = 10;      // 10进制
int i2 = 0b10;    // 2进制
int i3 = 010;     // 8进制
int i4 = 0x10;    // 16进制

快速打印

// sout 回车 输出语句
System.out.println();  
// psvm 主函数
public static void main(String[] args) {}

强制类型转换

和之前学习的写法有所不同

char a = '中';
System.out.println((int)a);
>>>> 20013
System.out.println((int)'s');
>>>> 115

unicode 编码，又称万国码，将世界上所有的文字用 2 个字节统一进行编码，而常用的 utf8 编码是 unicode 的一种实现方式(unicode在扩充表意文字时发现不够用了)，可根据不同编码通过变长(1~4字节)来表示，所以可以理解为什么汉字可以转换成数字

可以尝试打印一下看看汉字的编码范围，在 java 中是使用 UTF-16 的编码方式

System.out.println((char)13312);

ascii:65--a
unicode:61--a
utf-16:97--a

而普通类型转换可以不写，就是类似小范围转大范围，整数转小数这类的，略

内存溢出

顾名思义，就是数据与内存大小不匹配，装不下了

// 定义两个变量
int money = 10_0000_0000;
int years = 20;
// 变量相乘 一个乘之前做了类型转换 一个没有
long total = money*years;
long total2 = money*(long)years;
// 打印变量
System.out.println(total);
System.out.println(total2);

money*years 的值已经超过了 int 所能表示的最大值，就会溢出，结果如下

>>>> -1474836480
>>>> 20000000000

类与对象

类是变量(属性)和函数(方法)的集合，用 class 关键字标识

类有什么用? 为什么要把一堆数据函数绑定到一起? 这是为了实现封装，类是对现实生活中一类具有共同特征的事物的抽象，比如我要实现一个生成订单的功能，要扣减库存、扣减促销资源，更新用户账户等操作，我把这一系列操作抽象成一个订单类，需要的变量函数我都放到里面，这样就比较方便使用与理解

我们需要知道，类是一种数据类型，不是数据，不在内存中存储，所以我们需要实例化一个类，叫做对象，才能对它进行操作

public class a{}

变量作用域

包括类变量、实例变量、局部变量

public class Variable {
    static int allClicks = 0;   // 类变量 static关键字
    String str = "hello world!";    // 实例变量 不需要初始化即可使用 有默认值
  
    public void method(){
        int i = 0;  // 局部变量 必须声明和初始化
    }
}

局部变量就是只在最近的一个花括号内才能使用的变量

常量

使用 final 关键字，常量的名称一般用全大写的，比较容易区分

final double PI = 3.14;

修饰符

类似 final、static…等非数据类型的叫修饰符，不区分先后顺序，随意

static final double PI = 3.14;
final static double PI = 3.14;
public static final double PI = 3.14;

命名规范

推荐养成的习惯，便于阅读交流

所有变量名、方法名、类名:见名知意
类成员变量:首字母小写,后面单词首字母大写
局部变量:首字母小写,后面单词首字母大写
常量:全部字母大写,可加下划线 
类名:首字母大写,后面单词首字母大写 Man GoodMan
方法名:首字母小写,后面单词首字母大写 run() runRun()

运算符

java 支持如下运算符

算数运算符: + - * / %(取模) ++ --
赋值运算符: =
关系运算符: > < >= <= == != instanceof
位运算符: & | ^ ~ >> << >>>
条件运算符: ?:
扩展赋值运算符: += -= *= /=

位运算

因为任何计算都要转换为 01 序列进行运算，位运算在某些情况下可以提高计算机的运算效率

如计算 2 的 n 次幂

2^3 = 2<<3;

它的意思是将二进制数向左移 3 位，如何理解，拿十进制数看一下，0013，左移一位(空位补0)，0130，就是扩大了十倍，左移两位，1300，就是扩大了一百倍，同理，二进制数左移一位，就是扩大两倍，左移两位，就是四倍,10 位就是 2^10,1024 倍…类似的，可以增加幂运算的计算效率

关于a++和++a

int a = 3;
int b = a++;
System.out.println(a);
System.out.println(b);

>>> 4
>>> 3

要给程序一个入口 main 函数，一个项目一个 main 函数就可以

int a = 3;
int b = ++a;
System.out.println(a);
System.out.println(b);

>>> 4
>>> 4

区别就是如果自增运算符在后，是先赋值，a才会加一，在前面则是先加一再赋值

短路运算

在进行与(&&)运算的时候，必须两个都为真结果才为真，那么只要第一个条件为假，就不必判断后面的条件了，这就是所谓的短路运算

int c = 4;
boolean d = (c<4)&&(c++)<5;
System.out.println(c);
System.out.println(d);

>>> 4
>>> false

在判断完 c<4 为假，就进行一些操作将其简化为假，并不会判断后面的语句然后执行 c++，所以 c 的值仍然为 4

在这里插入图片描述

int c = 4;
if ((c < 4)) {
    c++;
}
boolean d = false;

可以看到只单独判断了 c 是否小于4

三元运算符

x ? y:z

如果 x 语句结果为真，则结果为 y，为假则结果为 z

int c = 4;
int result = c>5 ? c++ : c-- ;
System.out.println(c);
>>> 3

语句有一个返回结果，需要用变量接收

包机制

为了更好的组织类，java 提供了包机制，用于区别类名的命名空间，类似于文件夹的功能

package pkg1[.pkg2[.pkg3]...];

一般利用公司域名倒过来作为包名

导入包使用 import 语句

import package1[.package2...].(classname|*)

流程控制

接收用户输入 scanner

// 创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");

// 判断用户有没有输入字符串
if(scanner.hasNext()){
    String str = scanner.next();
    System.out.println("输出的内容为："+ str);
}
// IO流的类用完要随手关 养成节约资源的好习惯
scanner.close();

使用next方式接收：
hello world
输出的内容为：hello

使用 nextline 方法

String str = scanner.nextLine();

使用next方式接收：
hello world
输出的内容为：hello world

next 方法以空格作为结束符，nextline 以回车作为结束符

还可以简单判断数据的类型，例如

Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数:");
if(scanner.hasNextInt()){
    int i = scanner.nextInt();
    System.out.println("整数数据:"+i);
}else {
    System.out.println("输入的不是整数数据!");
}
scanner.close();

if 结构

if(布尔表达式/默认为true){
    // 如果布尔表达式为 true 将执行的语句 
}

if(布尔表达式/默认为true){
    // 如果布尔表达式为 true 将执行的语句 
}else{
    // 如果表达式为false
}

if(条件1){
    ...
}else if(条件2){
    ...
}else{
    // 都不满足时执行
}

switch 结构

switch(expression){
    case value1:
    // 语句
    break;//可选
    case value2:
    // 语句
    break;
    case value3:
    // 语句
    break;//可选  
    default: //可选
    // 语句
}

break 语句是跳出当前语句，即{}，结束 switch 语句，如果没有的话，在满足value2时，执行完对应的语句还会继续向下执行，不进行值的判断，直到遇到 break 语句或全部执行完才结束

while 循环

当满足条件时，执行语句

int i = 0;
while(i<100){
    i++;
}

do while 循环

一定会执行一次，然后判断是否满足条件，满足则继续执行

int i = 0;
do {
    i++;
}while (i<100);

for 循环

9.for 快速打印 i=0;i<9,i++ 的 for 循环

for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        int s = i*j;
        System.out.print(i+"*"+j+"="+s+"\t");
    }
    System.out.print("\n");
}

增强 for 循环，可以作为遍历数组集合的快捷方式

int[] numbers = {10,20,30,40,50};
for(int x:numbers){
    System.out.println(x);
}

跳出循环

break 中止循环，不执行剩余语句

continue 中止本次循环，直接进行下一次循环

小练习打印三角形

// 打印三角形 一共打印 I 行
final int I = 25;
// 打印第 k 行 
for (int k=0;k<I;k++){
    // 打印第 j 列
    for (int j = 1; j <=(2*I-1); j++) {
        // 当满足条件时 打印 *  否则打印空格
        if((I-k)<=j&&j<=(I+k)){
            System.out.print("*");
        }else {
            System.out.print(" ");
        }
    }
    System.out.println("");
}

因为所有输出结果都是一行一行打印的，所以我们只需要思考每一行中什么时候应该打印星号，什么时候打印空格

方法

定义

方法就是类函数，最常见的就是程序入口的 main 方法，下面是一个计算两数之和的简单方法

// public、static是修饰符 int是返回值类型,没有则是void addNum是函数名
public static int addNum(int a,int b){
    return a+b;
}
// 调用
int c = addNum(3,4);

某方法在读取到 return 语句时，该方法就会结束然后返回值

方法调用就是通过对象名.方法名

方法重载

在某个类中定义了多个方法名相同的方法，但是他们的参数数量不同或类型不同或顺序不同，就认定为不同方法，这就叫方法重载

参数顺序不同

public static int add(int a,float b){}
public static int add(float a,int b){}

形参类型不同

public static int add(int a,int b){}
public static int add(float a,int b){}

参数个数不同

public static int add(int a,int b){}
public static int add(int a,int b,int c){}

可变参数

因为 java 函数要求形参和实参的数量和类型都要匹配，但是有些时候需要传入的参数不确定，比如使用一些命令行工具可传入多个参数，对于这种不完全匹配的情况可以使用可变参数

 public static void test(double... numbers){}

递归

重复调用自身知道达到某一条件退出

public static long f(long n){
    if(n==1){
        return 1;
    }else {
        return n*f(n-1);
    }
System.out.println(f(25));

求阶乘的函数，返回f(n)=n*f(n-1),直到n=1停止，不推荐使用递归调用，因为调用程序需要不断压栈，可能导致程序溢出

数组

定义：相同类型数据的有序集合，类型必须相同，每个数据称作数组元素，可以通过下标访问

dataType[] a1;    // dataType[] 代表数组数据的类型 int、String...
dataType a2[];    // 在变量名后加中括号 非常不推荐

int[] nums = new int[10];   //初始化数组大小 动态初始化&默认初始化
int[] a = {1,2,3,4,5};      //静态初始化

需要定义数组的初始大小

nums[0] = 1;     // 赋值 有默认值
nums[5] = 100;

System.out.println(nums[5]);  //通过下标取值 大于范围会越界

多维数组

简单来说就是数组的元素还是数组

int[][] array = {{1,2,7},{2,3,5},{3,4,6},{4,5,9}}
array[0]-->{1,2}
array[0][1]-->2
array[2][2]-->6
int[][][] array= {{{1,2}, {1,2}, {5,6}},{{1,2},{5,6},{5,6}},{{1,2},{5,6},{5,6}}};

数组有个常用的 Arrays 类，ctrl+左键即可点击看源码，左侧结构/structure可看到相关方法，方便看源码，很多常用的工具类都是某些开发者写的一些函数，自己也可以开发

在这里插入图片描述

稀疏数组

这是用来压缩数据的一种方法，无论是传输还是存储，数据的压缩都是非常重要的

在这里插入图片描述

主要适用于有用数据比较少，大部分是一些无意义数据的情况，举例就是棋盘对局

然后第一行记录矩阵共有几行几列，几个数据，接下来就记录哪一行哪一列，数据的具体值是多少

面向对象OOP

这里只是初步了解，不做过多讲解

所谓面向对象，就是一种功能分类，首先考虑是宏观层面的，再考虑具体代码实现

本质是：以类的方式组织代码，以对象的形式封装数据

test 软件包下新建一个 Demo05 的 java 类

package test;

public class Demo05 {
    public static String test(){
        return "测试";
    }
}

test 软件包下新建一个 Demo01 的 java 类，调用 Demo05 的 test 方法

package test;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(Demo05.test());
    }
}

因为是静态函数，在 static main 方法中可以直接以类名.方法名调用，如果是非静态的，需要实例化，而类型就是类名

Demo05 a = new Demo05();
System.out.println(a.test());

静态方法在类存在的时候就存在了，而非静态的方法在实例化之后才存在

构造函数

在使用 new 实例化对象时会调用的方法

public Test(){}

函数名和类名一样，没有返回值，作用就是用来初始化定义一些值

还可以多个构造方法，比如一个有参数，一个没有参数，类似之前说的方法重载，一旦定义有参数的构造方法，就必须定义没有参数的构造方法

public Test(){}
public Test(String name){}

堆栈初步了解

java 中对象时保存在堆中的，数组对象也是在堆中，堆栈是两个比较常用的概念，我们目前只需要知道是辅助程序运行的，用于存放数据，标识运行状态的东西

举个例子，一个 main 函数，实例化一个 pet 类并调用赋值

在这里插入图片描述

堆栈中大致过程示意图(不完全)

在这里插入图片描述

程序无非就是操作一些数据，进行逻辑运算的，在堆中有专门的方法区，用来存放类相关数据，堆中还会存放实例化的对象什么的，栈一般存放方法(执行到哪个方法)和变量引用，然后到堆中去寻找具体的数据和方法，入栈出栈在之前都有接触过

封装

减少暴露在外的数据，我们在之前的一篇 php 反序列化习题的文章接触过就是私有属性

private name = "xiaoming";

无法通过类名.属性名进行赋值调用，但是可以通过类内的 get/set 方法来操作，保证操作在可控范围内，通过 get/set 加属性名进行定义

在这里插入图片描述

继承

继承是指类之间的一种关系，父类子类，子类继承父类，相当于对父类进行扩展

比如有学生类/老师类两个子类，他们都继承自父类-人类，学生类老师类相对于人类变得更具体了，扩展了一些属性和方法，一般使用 extends 关键字

public class Student extends Person{}

java 只有单继承没有多继承，也就是只能有一个父类，子类会拥有父类除了私有的(private)其它全部的属性和方法

在子类构造方法调用父类的构造方法使用 super 关键字,当然，还是不能调用私有属性的

super.test();
super.name;

方法重写和多态

子类如果要重写继承父类的方法，不要加 static 关键字，静态方法在最开始加载，子类的非静态方法重写会覆盖父类的方法，很容易理解，不贴代码了

A extends B
A a = new A();
B b = new A();

A 继承 B 类，两种写法都是可以实例化 A 的，区别在于，父类引用指向子类对象(B b=new A)只能调用子类中重写的父类方法(没有属性的事)，不能直接调用子类独有的方法，而子类引用指向子类对象，可以调用自己的所有方法，如果子类重写了某方法，则都会调用子类的方法

当然，也不是不可能，只要将对象进行类型转换就可以调用子类方法了，还是上面的例子,子类 A 中有一个 test 方法

A{
    test(){}
}

调用,引用子类 A 的对象 a 可以直接调用子类方法，而引用父类 B 的对象 b 需要进行类型转换才能调用(之前讲过的强制类型转换，和它很像)

a.test();
((A)b).test();

多态的一个比较大的作用就是解耦，什么意思呢？比如我设计了一个父类 List，还有一些子类，某一天我的一个子类 ArrayList 用不到了，需要修改为 LinkedList，只要修改实例化的子类名称就可以了，比较容易维护

List list = new ArrayList();
List list = new LinkedList();

抽象类

说抽象类呢，它只有方法的名字，没有方法的实现，使用 abstract 关键字定义

public abstract class Action{
    public abstract void dosomething();
}

由继承它的子类进行方法的实现，除非子类还是一个抽象类

接口

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现

接口由 interface 关键字定义，里面没有方法的实现，只需定义方法的名字，默认都是 public 的抽象类，需要在实现类里面写具体的代码

public interface UserService {
    void add(String name);
    void delete(String name);
}

实现类需要用 implements 关键字定义，Alt+Insert 快捷键插入实现方法

public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {
  
    }
    @Override
    public void delete(String name) {

    }
}

网上一堆眼花缭乱的什么接口和多继承有什么关系，没怎么看懂，倒是如果有十个接口的方法要实现，可以用所谓的继承在一个类里实现，既然最终都要在类里重写，不知道这一步有什么用，不过这种东西应该都是便于开发维护的东西，以后有了经验自然就知道了，没必要在这里硬抠

内部类

在类内定义类，如何调用?

package test;

public class Outer {
    private int id = 100;
    public void out(){
        System.out.println("外");
    }
    public class Inner{
        public void in(){
            System.out.println("内");
        }
    }
}

实例化外部类，然后再实例化内部类(java中可以直接在类内实例化自己)

package test;
import test.Outer;

public class test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
    }
}

还可以调用外部类的私有属性，和私有方法

private int id = 100;
private void test(){
    system.out.println("私有方法");
}

// 内部类调用
public class Inner{
    public void in(){
        System.out.println(id);
        test();
    }
}
//实例化调用
inner.in();

我觉得这个做题可能会用到

异常

程序经常会遇到各种各样的bug导致不能正常运行，这时就需要引入异常捕获机制，让程序更稳定的运行，即使有一些错误，也能照跑不误

举例：try 尝试执行代码块内的语句，如果catch语句捕捉到错误则执行catch代码块的语句，报错类型是根据语句决定的

int a = 2;
int b = 0;
try{
    System.out.println(a/b);
}catch(Exception e){
    System.out.println("xx");
}finally {
    System.out.println("fin");
}

finally 是不管是否报错，最终都会执行的语句

throw、throws一般是在方法里使用的，这里就不说了

自定义异常

自带的异常类不能满足我们的需求的时候可以自己写，java的很多东西都是可以自定义的，实现自定义异常类需要继承 Exception 类或其子类，如果自定义运行时异常类需继承 RuntimeException 类或其子类，这里不做讲解

练习

运行项目

将源码拖到编译器中，Maven 会自动加载需要的依赖包，然后一般是修改数据库配置等，再一键编译运行，这和 php 区别是比较大的

在这里插入图片描述

反编译 class 文件

直接将class文件拖到编译器，会直接显示反编译的文件

在这里插入图片描述

注意编码，可以看到 case 的值并不是明文，这是hashcode，通过它来指代

看完本套课程，印象最深的就是那句：程序，是对世界的建模！瞬间高大上起来了

重返太空

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java简易笔记一篇入门

java是一种面向对象的编程语言，有很多特定的工具类/函数，方便不同情景的快速编程，使用的开发工具是 IntelliJ IDEA ，本文只做基础了解文章目录java 基础java helloworld定义变量数据类型关于字节的科普进制快速打印强制类型转换内存溢出类与对象变量作用域常量修饰符命名规范运算符位运算关于a++和++a短路运算三元运算符包机制流程控制接收用户输入 scannerif 结构switch 结构while 循环do while 循环for 循环跳出循环小练习打印三角形方法定义方法重载可
复制链接

扫一扫