java入门基础

版权声明:访问者可将本网站提供的内容或服务用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯本网站及相关权利人的合法权利。转载请向作者申请(wwb159874@163.com)并标明出处: https://blog.csdn.net/Domino_b/article/details/79968899

语法基础

变量和常量

字符串

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

image

常用运算符

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

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

  • 算术运算符

  • 赋值运算符

  • 比较运算符

  • 逻辑运算符

  • 条件运算符

算术运算符

image

赋值运算符

image

比较运算符

image

逻辑运算符

image

条件运算符

条件运算符( ? : )也称为 “三元运算符”。

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

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

例如:
image

运算符的优先级

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

image

流程控制语句

与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 中常用的方法:

  1. 排序

    Arrays.sort(数组名); //升序

  2. 将数组转换为字符串

    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   // 第一个元素的数组长度(列数)

方法

基本语法

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

语法:

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

其中:

  1. 访问修饰符:方法允许被访问的权限范围, 可以是 public、protected、private 甚至可以省略 ,其中 public 表示该方法可以被其他任何代码调用,其他几种修饰符的使用在后面章节中会详细讲解滴

  2. 返回值类型:方法返回值的类型,如果方法不返回任何值,则返回值类型指定为 void ;如果方法具有返回值,则需要指定返回值的类型,并且在方法体中使用 return 语句返回值

  3. 方法名:定义的方法的名字,必须使用合法的标识符

  4. 参数列表:传递给方法的参数列表,参数可以有多个,多个参数间以逗号隔开,每个参数由参数类型和参数名组成,以空格隔开

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

  • 无参无返回值方法
  • 无参带返回值方法
  • 带参无返回值方法
  • 带参带返回值方法
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();

成员变量和局部变量

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

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

构造方法

  1. 使用new 构造方法();来创建一个新的对象。
  2. 构造方法是定义在Java类中的一个用来初始化对象的方法。
  3. 构造方法与类名相同且没有返回值。
  4. 语法:
public 构造方法名 (参数) {     // 构造方法名与类名相同
    // 初始化代码
}
  1. 当没有指定构造方法时,系统会自动填加无参的构造方法。若有指定则不会添加。
  2. 构造方法也可以重载

static

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

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

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

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

注意:

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

静态初始化块

在类的声明中,可以包含多个初始化块,当创建类的实例时,就会依次执行这些代码块。如果使用 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 {
    // 代码...
}

方法的重写

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

语法规则:

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

继承的初始化顺序

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

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关键字修饰。

作用:

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

应用场景:

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

使用规则:

  1. abstract定义抽象类
  2. abstract定义抽象方法,只有声明,不需要实现
  3. 包含抽象方法的类是抽象类
  4. 抽象类中可以包含普通的方法,也可以没有抽象方法
  5. 抽象类不能直接创建,可以定义引用变量
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();
}
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页