Domino_b的博客

counting stars

java入门基础

语法基础

变量和常量

字符串

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... 
{
    // 如果继承了抽象类,需要实现继承的抽象方法;要实现接口中的抽象方法。
}
阅读更多
文章标签: java
个人分类: java
想对作者说点什么? 我来说一句

Java 基础入门_传智播客.pdf

2017年12月14日 80.28MB 下载

Java基础入门——传智播客.pdf

2017年11月09日 103.83MB 下载

《Java基础入门》_课后题答案

2015年06月19日 181KB 下载

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

不良信息举报

java入门基础

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭