- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

【Java】基础语法 | OOP用法 | 集合框架

野猪佩奇996 发表于 2022/09/02 22:24:05 2022/09/02

【摘要】因为后面可能要接触flink的东西，先快速入门java，像语法和oop特性很多语言都是相通的~ 文章目录零、IDEA环境配置0.1 java项目跑起来一、基础内容1.1 ja...

因为后面可能要接触flink的东西，先快速入门java，像语法和oop特性很多语言都是相通的~

文章目录

零、IDEA环境配置
- 0.1 java项目跑起来
一、基础内容
二、并发
三、JVM
四、网络、linux、数据结构、数据库、系统设计
Reference

零、IDEA环境配置

0.1 java项目跑起来

首先新建项目，不用创建模板，然后打开项目中的src文件夹：

右击src选择new->Package：

得到如图：

在刚才新建的com.java.demo中右键new，java class，名字随便写个hello_andy：

在新建好的类中写一个main方法，和其他语言类似，java项目从这里开始执行：

最终的结果：

一、基础内容

1.1 java基本功

（1）Java 入门(基础概念与常识)

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。认识几个概念：

对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

注意：

一个.java文件内不是只能写一个class，是可以有多个类的，但是只能有一个public的类，并且该类名要和文件名相同。
一个文件中可以不含public类。

简单案例，循环，其中的打印System.out.print()，print()是一个方法，System是系统类，out是标准输出对象：

package com.java.demo;

public class loop_test {
    public static void main(String[] args){
        int x = 10;
        while (x < 15){
            System.out.print("value of x: " + x);
            x++;
            System.out.print("\n");
        }
    }
}
//value of x: 10
//value of x: 11
//value of x: 12
//value of x: 13
//value of x: 14

  
 
  
 
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

（2）Java 语法

java基本语法：

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

Java修饰符：像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

Java 中主要有如下几种类型的变量

局部变量
类变量（静态变量）
成员变量（非静态变量）

//java 的注释
public class HelloWorld {
   /* 这是第一个Java程序
    * 它将输出 Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String[] args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

（3）基本数据类型

六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型：byte、short、int、long、double、boolean、char。其中注意byte类型是8位，有符号的，以二进制补码表示的整数，即最小值是-128，最大值是127。

（4）方法(函数)

一个方法的定义：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

  
 
  1
  2
  3
  4
  5
  6

和C++语言不同的是，java可以定义finalize()方法来清除回收对象，关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用finalize方法：

package com.java.demo;

public class FinalizationDemo {
    public static void main(String[] args){
        Cake c1 = new Cake(1);
        Cake c2 = new Cake(2);
        Cake c3 = new Cake(3);

        c2 = c3 = null;
        // 调用java垃圾收集器
        System.gc();
    }
}

class Cake extends Object{
    private int id;
    public Cake(int id){
        this.id = id;
        System.out.println("Cake Object " + id + "is created");
    }

    protected void finalize() throws java.lang.Throwable{
        super.finalize();
        System.out.println("Cake Object " + id + "is disposed");
    }
}

  
 
  
 
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26

（5）java源程序与编译型运行的区别

1.2 Java 面向对象

（1）类和对象

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

java中是通过new实例化对象，和其他oop一样，同时会调用构造方法初始化对象。

（1）栗子1：访问实例变量和调用成员方法：

package com.java.demo;

public class Puppy{
    int puppyAge;
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
        System.out.println("小狗的名字是 : " + name );
    }

    public void setAge( int age ){
        puppyAge = age;
    }

    public int getAge( ){
        System.out.println("小狗的年龄为 : " + puppyAge );
        return puppyAge;
    }

    public static void main(String[] args){
        /* 创建对象 */
        Puppy myPuppy = new Puppy( "tommy" );
        /* 通过方法来设定age */
        myPuppy.setAge( 2 );
        /* 调用另一个方法获取age */
        myPuppy.getAge( );
        /*你也可以像下面这样访问成员变量 */
        System.out.println("变量值 : " + myPuppy.puppyAge );
    }
}
//小狗的名字是 : tommy
//小狗的年龄为 : 2
//变量值 : 2

  
 
  
 
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32

（2）import外部文件的类：import java.io.*;将会命令编译器载入 java_installation/java/io 路径下的所有类：
首先是员工类：

package com.java.demo;

import java.io.*;

public class Employee {
    // public: name实例变量对子类可见
    public String name;
    int age;
    String designation;
    // private: 私有变量，仅在该类可见
    private double salary;

    // Employee 类的构造器
    public Employee(String name) {
        this.name = name;
    }

    // 设置age的值
    public void empAge(int empAge) {
        age = empAge;
    }

    /* 设置designation的值*/
    public void empDesignation(String empDesig) {
        designation = empDesig;
    }

    /* 设置salary的值*/
    public void empSalary(double empSalary) {
        salary = empSalary;
    }

    /* 打印信息 */
    public void printEmployee() {
        System.out.println("名字:" + name);
        System.out.println("年龄:" + age);
        System.out.println("职位:" + designation);
        System.out.println("薪水:" + salary);
    }
}

  
 
  
 
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40

接着是main函数，同样是开头有句import java.io.*;找到我们上面的员工类：

package com.java.demo;

import java.io.*;
public class EmployeeTest{

    public static void main(String[] args){
        /* 使用构造器创建两个对象 */
        Employee empOne = new Employee("RUNOOB1");
        Employee empTwo = new Employee("RUNOOB2");

        // 调用这两个对象的成员方法
        empOne.empAge(26);
        empOne.empDesignation("高级程序员");
        empOne.empSalary(1000);
        empOne.printEmployee();

        empTwo.empAge(21);
        empTwo.empDesignation("菜鸟程序员");
        empTwo.empSalary(500);
        empTwo.printEmployee();
    }
}

  
 
  
 
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22

（2）面向对象三大特征

1）继承

Java通过extends申明继承。和其他oop语言类似，子类拥有父类非private的属性和方法，也可以用自己的方式实现父类的方法。
Java是单一继承，即不支持多继承（子类继承多个父类），但是支持多重继承（如下图）。

C++和Java中调用自身类是用this，如果调用自身类的方法则用this.xxx_function，而python中调用自身类的方法是用self.xxx_function；
Java和python调用父类的方法可以直接用super，但是C++没有super；
在C++中，子类和父类函数名一样的函数fun，如果参数不一样，不管加不加virtual，当子类调用fun()时，会先在子类中找，找不到会报错。

2）多态

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

java中的多态：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

package com.java.demo;

public class DuotaiTest {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法
        //父类引用指向子类对象
        A a = new Cat();  // 向上转型
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();        // 调用的是 Cat 的 work
    }

    public static void show(A a)  {
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}
//父类animal
abstract class A {
    abstract void eat();
}

class Cat extends A {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends A {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}

  
 
  
 
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47

结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

  
 
  1
  2
  3
  4
  5
  6

3）封装

略。

（3）修饰符

（4）接口和抽象类

（5）Java包

1.3 Java 核心技术

（1）集合

先浏览下图的Java集合框架图，Java 集合框架主要包括两种类型的容器：

一种是集合（Collection），存储一个元素集合。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
另一种是图（Map），存储键/值对映射。

所有的集合框架都包括（参照下图，java集合框架位于java.util包中，所以当使用集合框架的时候需要进行导包）：

接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

（2）异常

略。

（3）多线程

一个线程的生命周期：

（4）文件与 I\O 流

一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。下图是一个描述输入流和输出流的类层次图。

二、并发

2.1 并发容器

JDK 提供的并发容器总结
ConcurrentHashMap
CopyOnWriteArrayList
ConcurrentLinkedQueue
BlockingQueue
ConcurrentSkipListMap

2.2 线程池

使用线程池的好处
Executor 框架
(重要)ThreadPoolExecutor 类简单介绍
(重要)ThreadPoolExecutor 使用示例
几种常见的线程池详解
ScheduledThreadPoolExecutor 详解
线程池大小确定

2.3 乐观锁与悲观锁

何谓悲观锁与乐观锁
乐观锁常见的两种实现方式
乐观锁的缺点
CAS与synchronized的使用情景

三、JVM

（1）Java内存区域
概述
运行时数据区域
HotSpot 虚拟机对象探秘
重点补充内容

（2）JVM垃圾回收
揭开 JVM 内存分配与回收的神秘面纱
对象已经死亡?
垃圾收集算法
垃圾收集器

（3）JDK 监控和故障处理工具
JDK 命令行工具
JDK 可视化分析工具

四、网络、linux、数据结构、数据库、系统设计

略，参考408系列。

Reference

[1] https://edu.csdn.net/job/javabe_01/java-4744df73a92b434593040c21501362c3
[2] runoob教程：https://www.runoob.com/java/java-character.html
[3] Spark之IDEA创建基于Scala语言的Spark Maven项目

文章来源: andyguo.blog.csdn.net，作者：山顶夕景，版权归原作者所有，如需转载，请联系作者。

原文链接：andyguo.blog.csdn.net/article/details/126199628

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入