java基础目录

最新推荐文章于 2024-01-23 14:11:58 发布

hugh Lee

最新推荐文章于 2024-01-23 14:11:58 发布

阅读量1.9k

点赞数 2

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

本文链接：https://blog.csdn.net/qq_33530388/article/details/57126482

版权

java 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

本来就学的不咋地，这么久没碰过，自然就，，，，，忘了

以下回顾是对本人的忘记之处的总结，对于特别easy的地方请大佬轻喷。

首先，一个 Java源文件中最多只能有一个 public类，

当有一个 public类时，源文件名必须与之一致，否则无法编译，如果源文件中没有一个public类，则文件名与类中没有一致性要求。

至于main()，不是必须要放在public类中才能运行程序。
（另外，与源文件同名的public类不能是抽象类）
（原因见http://blog.csdn.net/bareheadzzq/article/details/6562211）

其次是输入输出：
输入：使用Scanner工具类来获取用户的输入信息
Scanner工具类位于java.util包中，使用时需要导入此包(里面的Scanner类)
步骤：
1、导入java.util.Scanner类
2、创建Scanner对象
3、接收并保存输入的值

import java.util.Scanner;
public class sca{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in); //创建Scanner对象
        String get=input.next();    //通过对象的内置方法接收数据    （.nextInt方法是接收int型数据输入）
    }
}

输出：

System.out.println();

一、变量的类型

这里写图片描述
String 也是一种常见的引用数据类型，注意是S而不是小写的s。
String.equals()用于判断字符串的内容是否一样，一样返回true

这里写图片描述

float型 内存分配4个字节,占32位,范围从10^-38到10^38 和 -10^38到-10^-38
例float x=123.456f,y=2e20f; 注意float型定义的数据末尾必须有”f”或”F”,为了和double区别
double型 内存分配8个字节,范围从10^-308到10^308 和 -10^-308到-10^-308
例double x=1234567.98,y=8980.09d; 末尾可以有”d”也可以不写

自动类型转换要满足的条件：
1. 目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型
2. 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了

二、注释

重点是 文档注释（/** …. */）
可以用标记来保存信息，接着用 javadoc命令来编写文档
（javadoc [options] [packagenames] [sourcefiles]）
【详见 http://www.cnblogs.com/bluestorm/archive/2012/10/04/2711329.html】

三、运算符

这里主要说逻辑运算符里的异或
这里写图片描述

异或：有且只能有一个为true，才返回

当使用逻辑运算符时，我们会遇到“短路”现象。
譬如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 了
同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 了

这里写图片描述

四、条件语句以及循环语句

条件语句 主要是 switch
1、 switch 后面小括号中表达式的值必须是整型或字符型
2、 case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2
3、 case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束
4、可以把功能相同的 case 语句合并起来，如

case 1:
case 2:
    System.out.println("同一个结果");

5、 default 块可以出现在任意位置，也可以省略

循环语句
循环语句有个不常见的 foreach
foreach 并不是 Java 中的关键字，而是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。
语法：
这里写图片描述

eg:
for(String hobby:hobbys){
    System.out.println(hobby);
}

五、数组

1、声明数组
语法：数据类型[ ] 数组名；
或者数据类型数组名[ ]；

2、分配空间
简单地说，就是指定数组中最多可存储多少个元素
语法：数组名 = new 数据类型 [ 数组长度 ];
其中，数组长度就是数组中能存放元素的个数，如：

int[] score;
score=new int[5];

话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：
int[] score=new int[5];

3、赋值
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的

4、处理数组中数据
我们可以对赋值后的数组进行操作和处理

在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如

int[] score={12,23,34,45,56};

它等价于：

int[] score=new int[]{12,23,34,45,56};
///new int[]这里方括号里必须为空，不能指定长度

这里写图片描述

数组名.length 用于获取数组的长度
(对于上例二维数组来说，获得二维数组的行数长度–num.length,
获得二维数组其中一行的长度为–num[i].length)

数组的操作类

使用 Arrays 类操作 Java 中的数组
Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等
Arrays 中常用的方法：
1、排序
语法： Arrays.sort(数组名);
可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列）

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

记得导入import java.util.Arrays;包

六、类

除了上面的操作数组的 java.util.Arrays类外，再介绍个常用的
Java.lang.Math 类，Math类包含的方法能进行基本的数字操作

通过 (int)(Math.random() * 100) 生成 100 以内的随机数
注：Math 类是用于进行算术操作的类，Math.random() 生成 0–1 的浮点数。

(int)Math.random()的结合性比Math.random()*100的要高，所以注意加小括号（即强制类型转换的优先级高于算数符号的优先级）

static 使用之静态初始化块

Java 中可以通过初始化块进行数据赋值。如：

public class HelloWorld{
    String name;  //定义一个成员变量
    //通过初始化块为成员变量赋值
    {
        name="良哥哥";
    }
}

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

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

这里写图片描述
运行结果：

这里写图片描述

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

七、封装

包与导包

包的命名规范是 全小写字母拼写

可以通过import关键字，在某个文件使用其他文件中的类(import 包名)
使用的时候不但可以加载某个包下面的所有文件
eg: com.hugh.*
也可以加载某个具体子包下的所有文件
eg: com.hugh.music.*

导包导入的是该包下级目录中的类，而下下级中的类并没有导入

访问修饰符

这里写图片描述

内部类

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

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

//外部类HelloWorld
public class HelloWorld {

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

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

    public static void main(String[] args) {

        // 创建外部类对象
        HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        Inner i = hello.new Inner(); //注意创建方法
        // 调用内部类对象的方法
        i.show();
    }
}

内部类可分为以下几种：
成员内部类
 静态内部类
 方法内部类
 匿名内部类

成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：这里写图片描述

运行结果为：这里写图片描述

从上面的代码中我们可以看到，成员内部类的使用方法：
1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类对象名 = 外部类对象.new 内部类( );

4、编译上面的程序后，会发现产生了两个 .class 文件

这里写图片描述

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，
1、 外部类是不能直接使用内部类的成员和方法的

可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：
这里写图片描述
运行结果：

静态内部类

静态内部类是 static 修饰的内部类
对于静态内部类要注意：
1、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问
2、如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名= new 内部类();
这里写图片描述

运行结果：

方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
这里写图片描述
由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

匿名内部类

匿名内部类继承父类或者实现某个接口，多用于函数的传递参数那块（作为实参对象传给形参，此时形参相当于一个对象引用，通过这个引用来使用匿名内部类对象的方法）（或者匿名内部类对象作为返回值 return给调用函数）

另外，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用。

这里写图片描述
如图，红圈之内的为匿名内部类创建时被立刻创建的一个该类的实例，即为匿名内部类对象，所以能在后面直接通过 .成员方法来使用内部的方法

对于匿名内部类在这里给出两个参考博客吧。
http://blog.csdn.net/chenssy/article/details/13170015这个写的挺好的
http://blog.csdn.net/huntersnail/article/details/48437195

八、继承

java中的继承是单继承

使用关键字extends

继承的初始化顺序

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

先进行父类对象属性 的初始化，接着调用父类的构造方法
然后是子类对象属性的初始化，接着调用子类的构造方法

方法的重写

方法的 重写：
子类对继承父类的方法不满意时，可以重写父类继承的方法，当调用方法时会优先调用子类的方法

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

（另外，不能减少继承方法的可见性，即原父类方法是 public修饰不能在子类的重写方法中减少为protected/private修饰，但是可以增加继承方法的可见性，即原父类方法是 protected修饰的，可以在子类的重写方法中增加为 public修饰）

final关键字

这里写图片描述

super关键字

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

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

Object类

object类是所有类的父类，object类中的方法，适合所有的子类

object类中的方法:

1、toString ()方法

在代码里直接输出对象，则会输出这个对象在内存中的地址，把这个地址称为哈希码

哈希码是通过哈希算法生成的一个字符串，用来唯一区分对象的（类似于身份证号）

通过哈希算法能得到对象的哈希码（对象地址字符串，用来唯一标识一个对象）

可以通过重写父类(object类)的toString()方法来使得输出一个对象之后能直接输出这个对象的属性值

2、equals()方法

dog wang=new dog()
wang是引用，new dog()是对象

== 比较的是对象的引用是否指向同一块内存地址
equals()方法是比较对象是否一样（属性值是否一样等等）

即“==”比较的是值【变量(栈)内存中存放的对象的(堆)内存地址】
equals()用于比较两个对象的值是否相同【不是比地址】
具体==与equals()方法的区别可见
http://blog.csdn.net/xcysuccess3/article/details/6557771

九、多态

多态的分类

1、引用多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象
2、方法多态
父类引用指向父类对象时，调用的方法是父类的方法
父类引用指向子类对象时，调用的方法是子类重写的方法或者继承的方法

多态要点：

1）多态的三大必要条件：继承、覆写、父类引用指向子类对象。
2）父类的实例方法可以被覆盖，属性不能被覆盖。
3）父类的引用可以访问父类的所有属性和方法，可以访问子类覆盖的方法（引用指向子类对象的话），但不能访问子类的属性（属性不能被覆盖），及子类新添加的方法。（动态连接、动态调用）

动态绑定

父类引用会调用子类覆盖的方法即 动态绑定，指定是程序在执行时（非编译期间）会判断引用对象的实际类型，并调用其相应的方法。

多态中的引用类型转换

问题：定义一个父类animal,和继承animal的两个子类dog和cat。
定义一个dog对象，用animal类型的引用是没问题的（向上类型转换），再把animal类型的引用赋值到一个dog类型的引用上去（向下类型转换-强制类型转换），也是没问题的（但存在安全风险）
但如果 定义一个dog对象，用animal类型的引用后，再把animal类型的引用赋值到一个cat类型的引用上（向下类型转换-强制类型转换），虽然编译的时候没有报错，但是运行的时候就出现问题了

这时，要通过 instanceof运算符 来解决引用对象的类型，避免类型转换的安全性问题（向下类型转换-强制类型转换）

格式：对象 instanceof B类，看对象里是否有B类的元素，有的话返回true（搭配if语句使用，为true后再进行转换）

抽象类

使用 abstract关键字修饰

包含抽象方法的类是抽象类，抽象类也可以没有抽象方法（抽象方法没有方法体，以分号结束）

抽象类不能直接创建，可以定义引用变量（通常是定义一个抽象类的引用变量，指向一个子类对象）

abstract class Animal{
 abstract void grow(); 
}

接口

概要

接口是一种规范，使用的是 interface关键字

这里写图片描述

接口是一种抽象类，只不过里面的内容全都是常量或者是抽象方法

接口可以继承多个父接口

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

这里写图片描述

通常 使用一个接口的引用指向一个实现了接口的对象

使用接口：接口在使用过程中，还经常与匿名内部类配合使用 (可以查看上面的匿名内部类章节)

接口特性：

1.接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

2.接口中每一个方法也是隐式抽象的，接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。接口中的方法都是公有的。

3.接口中可以含有变量，但是接口中的变量 会被 隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。

4.接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而 抽象类是可以有静态代码块和静态方法

5.一个类只能继承一个抽象类，而一个类却可以实现多个接口。

6.当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

—–未完待续

hugh Lee

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
java基础目录

本来就学的不咋地，这么久没碰过，自然就，，，，，忘了以下回顾是对本人的忘记之处的总结，对于特别easy的地方请大佬轻喷。首先是输入输出：输入：使用Scanner工具类来获取用户的输入信息 Scanner工具类位于java.util包中，使用时需要导入此包(里面的Scanner类) 步骤： 1、导入java.util.Scanner类 2、创建Scanner对象 3、接收并保存输入
复制链接

扫一扫