java入门基础

最新推荐文章于 2024-03-13 16:58:20 发布

Soul_wwb

最新推荐文章于 2024-03-13 16:58:20 发布

阅读量2.9k

点赞数 5

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/domino_b/article/details/79968899

版权

java 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

语法基础

变量和常量

字符串

tring 类型是引用类型

字符串拼接可以直接用加号连接

自动类型转换

向上类型转换，是小类型到大类型的转换。

和C语音一样

int类型可以自动转换为double

但是double需要强制转换才能转换为int

强制类型转换

向下类型转换，是大类型强制转换到小类型的转换。

语法：( 数据类型 ) 数值

int b = (int)a;

将double的值转换为int会直接从小数点处截断

常量

final String STR = "常量";

注释

分为文档注释、多行注释、单行注释

package com.imooc;
/**
 * 这是文档注释
 * @author wwb
 * @version v1.0
 */
public class Demo01 {
    /* 
     * 这是多行注释
     * 多行注释
     */
    public static void main(String[] args) {
        // 单行注释
        System.out.println("Hello JAVA!");
    }
}

PS：使用文档注释时还可以使用 javadoc 标记，生成更详细的文档信息：

@author 标明开发该类模块的作者
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@param 对方法中某参数的说明
@return 对方法返回值的说明
@exception 对方法可能抛出的异常进行说明

根据注释自动生成API帮助文档

可以使用javadoc命令从文档注释中提取内容，生成程序的 API 帮助文档。

javadoc -d doc Demo01.java

常用运算符

运算符是一种“功能”符号，用以通知 Java 进行相关的运算。

Java 语言中常用的运算符可分为如下几种：

算术运算符
赋值运算符
比较运算符
逻辑运算符
条件运算符

算术运算符

赋值运算符

比较运算符

逻辑运算符

条件运算符

条件运算符（ ? : ）也称为 “三元运算符”。

语法形式：布尔表达式 ? 表达式1 : 表达式2

运算过程：如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值

例如：

运算符的优先级

级别为 1 的优先级最高，级别 11 的优先级最低。

流程控制语句

与C/C++一致

数组

基础语法

语法：

int[] scores = {1,2,3,4,5};     // 声明并分配空间&赋值
// 等价于
int[] scores = new int[]{1,2,3,4,5};    // 后面[]中不能指定大小

// 声明
int[] scores;       // 或者下面这种
double height[];
String[] names;

分配空间：

scores = new int[5];        // 长度为5的整数数组
height = new double[5];
names = new String[5];

int[] scores = new int[5];  // 声明并分配空间

赋值或操作数组：

scores[1] = 80;                 // 赋值
System.out.println(scores[1]);  // 输出

使用Arrays类操作数组

Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。

需要导入Arrays类

import java.util.Arrays;

Arrays 中常用的方法：

排序

Arrays.sort(数组名); //升序
将数组转换为字符串

Arrays.toString(数组名);

可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开。

用foreach操作数组

foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思。

语法：

for (元素类型 元素变量:遍历对象) {
  // 执行代码
}
// 例如
int[] scores = { 89, 72, 64, 58, 93 };
for (int score : scores) {
    System.out.println(score);
}

二维数组

声明数组并分配空间

语法：

数据类型[][] 数组名 = new 数据类型[行的个数][列的个数];
// 或者
数据类型[][] 数组名;
数组名 = new 数据类型[行的个数][列的个数];

// 声明的同时赋值
数据类型[][] 数组名 = {{1,2,3},{4,5,6}};   // 两行三列
int[][] arr = {{1,2,3},{4,5,6}}
arr.length      // 行数
arr[0].length   // 第一个元素的数组长度(列数)

方法

基本语法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

语法：

访问修饰符 返回值类型 方法名(参数列表) {
  // 方法体
}

其中：

访问修饰符：方法允许被访问的权限范围，可以是 public、protected、private 甚至可以省略，其中 public 表示该方法可以被其他任何代码调用，其他几种修饰符的使用在后面章节中会详细讲解滴
返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值
方法名：定义的方法的名字，必须使用合法的标识符
参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开

根据方法是否带参、是否带返回值，可将方法分为四类：

无参无返回值方法
无参带返回值方法
带参无返回值方法
带参带返回值方法

public class HelloWorld {
    public static void main(String[] args) {
        // 创建对象，对象名为hello
        HelloWorld hello = new HelloWorld();    
        // 调用方法
        hello.say();
    }
    /*
     * 定义无参无返回值的方法
     */
    public void say() {
        System.out.println("hello!");
    }
}

方法的重载

如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。

当调用被重载的方法时， Java 会根据参数的个数和类型来判断应该调用哪个重载方法，参数完全匹配的方法将被执行。

（与C++的重载一致）

判断方法重载的依据：

1、必须是在同一个类中

2、方法名相同

3、方法参数的个数、顺序或类型不同

4、与方法的修饰符或返回值没有关系

例子：

public class HelloWorld {
    public static void main(String[] args) {
        // 创建对象
        HelloWorld hello = new HelloWorld();
        // 调用无参的方法
        hello.print();
        // 调用带有一个字符串参数的方法
        hello.print("tom");
        // 调用带有一个整型参数的方法
        hello.print(18);
    }

    public void print() {
        System.out.println("无参的print方法");
    }

    public void print(String name) {
        System.out.println("带有一个字符串参数的print方法，参数值为：" + name);
    }

    public void print(int age) {
        System.out.println("带有一个整型参数的print方法，参数值为：" + age);
    }
}

类和对象

类的定义

public class Telephone {
  // 属性
  float screen;
  float cpu;
  float mem;
  // 方法
  void call() {
    System.out.println("calling...");
  }
}

类可以实例化为对象

// 类名 对象名 = new 类名();   // 构造方法
Telephone phone = new Telephone();

成员变量和局部变量

成员变量在类中定义（不一定要赋初值）。可以被同一个类的方法访问到。

局部变量在方法中定义（需要赋初值）。只能在本方法内访问。

构造方法

使用new 构造方法();来创建一个新的对象。
构造方法是定义在Java类中的一个用来初始化对象的方法。
构造方法与类名相同且没有返回值。
语法：

public 构造方法名 (参数) {     // 构造方法名与类名相同
    // 初始化代码
}

当没有指定构造方法时，系统会自动填加无参的构造方法。若有指定则不会添加。
构造方法也可以重载

static

我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时可以用static修饰。

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。推荐使用类名访问。

静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收。

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。

注意：

静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

静态初始化块

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象时并未执行静态初始化块。

封装

概念

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法(set、get)来实现对隐藏信息的操作和访问

用包管理Java中的类

作用

管理Java文件；
解决同名文件冲突；

定义包

必须放在Java源程序的第一行，包名间可以用‘.’隔开。

比如：com.imooc.MyClass代表最底层是com，然后是imooc，按层次结构命名比较好。

包的使用

可以通过import关键字，在某个文件中使用其他文件中的类。
Java中，包的命名规范是全小写字母
加载某个包下面所有的文件可以这么写
```
import com.imooc.*
```

访问修饰符

可以修饰属性和方法的访问范围

访问修饰符	本类	同包	子类	其他
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

this关键字

this关键字代表当前对象

封装对象的属性的时候，经常会用this关键字

内部类

内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

作用：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

内部类可以分为：

成员内部类
静态内部类
方法内部类
匿名内部类

//外部类HelloWorld
public class HelloWorld {

    // 内部类Inner，类Inner在类HelloWorld的内部
    public class Inner {

        // 内部类的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }

    public static void main(String[] args) {
        // 创建外部类对象
        HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        Inner i = hello.new Inner();
        // 调用内部类对象的方法
        i.show();
    }
}

成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。

内部类可以使用任意访问控制符
内部类中定义的方法可以直接访问外部类中的任意数据，不受访问控制符影响
使用内部类必须先创建一个外部类的对象，然后通过外部类来new一个内部类对象，不能直接new一个内部类对象
编译后会产生两个class
外部类不能直接使用内部类的方法，可以先创建内部类对象，然后通过内部类的对象访问其成员变量和方法
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：Outer.this.var

静态内部类

静态内部类是 static 修饰的内部类，这种内部类的特点是：

静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
如果外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类对象名= new 内部类();

//外部类
public class HelloWorld {

    // 外部类中的静态变量score
    private static int score = 84;

    // 创建静态内部类
    public static class SInner {
        // 内部类中的变量score
        int score = 91;

        public void show() {
            System.out.println("访问外部类中的score：" +     HelloWorld.score  );
            System.out.println("访问内部类中的score：" + score);
        }
    }

    // 测试静态内部类
    public static void main(String[] args) {
        // 直接创建内部类的对象
        SInner si = new SInner();     
        // 调用show方法
        si.show();
    }
}

方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

继承

概念

继承是一种类与类的关系，Java中的继承是单继承。

子类拥有父类的所有属性和方法，实现代码复用。

语法：

class Dog extends Animal {
    // 代码...
}

方法的重写

子类继承父类时，可以对父类的方法进行重写，当调用方法时会优先调用子类的方法。

语法规则：

方法的返回类型，方法名，参数类型及个数都要与父类继承的方法相同，才叫方法的重写。

继承的初始化顺序

初始化父类再初始化子类
先执行初始化对象中的属性，再执行构造方法中的初始化

final关键字

用final修饰的东西不可以被修改

final可以修饰类、方法、属性和变量

修饰类，则该类不允许被继承
修饰方法，则该方法不允许被重写
修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）
修饰变量，则该变量只能赋一次值，即为常量

super关键字

在对象内部使用，可以代表父类对象。

子类的构造过程当中必须调用其父类的构造方法。

如果子类的构造方法中没有显式调用父类的构造方法，则系统默认调用父类无参的构造方法。

如果显式地调用构造方法，必须在子类构造方法的第一行。

如果子类构造方法中没有显式地调用父类的构造方法，而父类中又没有无参的构造方法，此时编译器会报错。

Object类

Object类是所有类的父类，Object类中的所有方法都可以在所有子类中调用。

toString()

返回对象的哈希code码（对象地址字符串）

可以重写toString()方法来输出对象的属性。

equals()

比较的是对象的引用是否指向同一块内存地址。

同一个类生成的两个对象，就算值是一摸一样的，但是通过equals()方法判断出来的结果也是false，也可以用==，结果和调用equals()方法是一样的。只有两者是同一个对象的时候才返回true。

如果需要判断两个对象值是否相等，需要重写equals方法。

多态

对象的多种形态

引用的多态

父类的引用可以指向本类的对象。

父类的引用可以指向子类的对象。

Animal obj1 = new Animal();         // 父类的引用可以指向本类的对象
Animal obj2 = new Dog();            // 父类的引用可以指向子类的对象，这种形式称为多态
// Dog obj3 = new Animal();         // 错误的

方法的多态

创建本类对象时，调用的方法为本类方法。

创建子类对象时，调用的方法为子类重写的方法或者继承的方法，但是父类不能调用子类中独有的方法。

instanceof关键字

进行多态中的引用类型转换时，可以用instanceof来判断是否能进行转换。

抽象类

语法：

抽象类前使用abstract关键字修饰。

作用：

限定子类必须实现某些方法，但不关注实现细节。

应用场景：

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

使用规则：

abstract定义抽象类
abstract定义抽象方法，只有声明，不需要实现
包含抽象方法的类是抽象类
抽象类中可以包含普通的方法，也可以没有抽象方法
抽象类不能直接创建，可以定义引用变量

public abstract class Telephone {
    public abstract void call();
    public abstract void message();
}

// 然后创建子类继承他，重写方法就好了

接口

概念：

接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。

类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

语法：

[修饰符] interface 接口名 [extends 父接口1,父接口2...] 
{
    // 常量的定义
    public static final int var;  // 即使不写前面的修饰，编译器也会自动加上
    // 抽象方法的定义
    public abstract void func();  // 即使不写前面的修饰，编译器也会自动加上
}
// 接口是用来被继承、实现的，所以修饰符一般建议用public

使用：

一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。

                // 如果要继承父类，extends要在implements前
[修饰符] class 类名 extends 父类 implements 接口1,接口2... 
{
    // 如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
}

异常

try-catch 和 try-catch-finally

try{
    // 执行代码
} catch (InputMismatchException e) {
    // 处理错误
    e.printStackTrace();
} catch (ArithmeticException e) {
    // ...
} finally {
    // 最终要执行的代码 
}

异常的抛出

public void divide(int a,int b) throws Exception {  // 声明会抛出什么类型的异常
    if (b == 0) 
        throw new Exception("除数为0");            // 抛给上一层，交由上层处理
    else 
        System.out.println("结果为：" + a/b);
}

自定义异常

public class myException extends Exception {
    public myException(String message) {
        super(message);        
    }
}

包装类

为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。

自动装箱/拆箱

public class HelloWorld {
    public static void main(String[] args) {
        // 定义double类型变量
        double a = 91.5;
         // 手动装箱
        Double b = new Double(a);       
        // 自动装箱
        Double c = a;       
        System.out.println("装箱后的结果为：" + b + "和" + c);
        // 定义一个Double包装类对象，值为8
        Double d = new Double(87.0);
        // 手动拆箱
        double e = d.doubleValue();
        // 自动拆箱
        double f = d;
         System.out.println("拆箱后的结果为：" + e + "和" + f);
    }
}

日期相关

Date和SimpleDateFormat

在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用 java.util 包中的 Date 类。这个类最主要的作用就是获取当前时间。

Date d = new Date();
System.out.println(d);  // Tue Jul 17 17:17:57 CST 2018

可以使用 SimpleDateFormat 来对日期时间进行格式化，可以将日期转换为指定格式的文本，也可将文本转换为日期。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String timeNow = sdf.format(d);
System.out.println(timeNow);            // 2018-07-17 17:22:47

使用 parse() 方法将文本转换为日期

SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = "2014-6-1 21:05:36";
Date date1 = null;
try {
    date1 = sdf1.parse(str);            // 需要用try-catch包围，因为可能会抛出错误
} catch (ParseException e) {
    e.printStackTrace();
}
System.out.println(date1);

Calendar

Date 类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用 Calendar 类进行时间和日期的处理。

java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();

public static void main(String[] args) {
        // 创建Calendar对象
        Calendar c = new Calendar.getInstance();

        // 将Calendar对象转换为Date对象
        Date date = c.getTime()

        // 创建SimpleDateFormat对象，指定目标格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        // 将日期转换为指定格式的字符串
        String now = sdf.format(date);
        System.out.println("当前时间：" + now);
}

集合框架

作用

在类的内部，对数据进行组织；
简单而快速地搜索大数量的条目；
有的集合接口，提供了一些列排列有序的元素，并且可以在序列中间快速地插入或者删除有关元素；
有的集合接口，提供了映射关系，可以通过关键字(key)去快速查找到对应的唯一对象，而这个关键字可以是任意类型。

与数组的区别

数组的长度固定，集合长度可变；
数组只能通过下表访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象；
*

collection

是List、Set和Queue接口的父接口

定义了可用于操作List、Set和Queue的方法（增删改查）

List接口

List是元素有序并且可以重复的集合，被成为序列

List可以精确地控制每个元素的插入位置，或删除某个位置元素

动态加载类

静态加载

静态加载是在编译的时候就加载的，用new的都是静态加载

动态加载

运行时加载

try {
    Class c = Class.forName(args[0])  // args[0]运行时带入的第一个参数，这里填需要加载的类名
}
catch (Exception e) {
    e.printStackTrace();
}

Soul_wwb

关注

5
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
java入门基础

语法基础变量和常量字符串tring 类型是引用类型字符串拼接可以直接用加号连接自动类型转换向上类型转换，是小类型到大类型的转换。和C语音一样int类型可以自动转换为double但是double需要强制转换才能转换为int强制类型转换向下类型转换，是大类型强制转换到小类型的转换。语法：( 数据类型 ) 数值int b = (int)...
复制链接

扫一扫