孙肖宁 发布的文章

java中,当子类重写父类的方法后,子类对象将无法访问父类被重写的方法,为了解决这一问题,在java中专门提供了一个super关键字用于访问父类的成员(成员变量、成员方法和构造方法)。

使用super关键字调用父类的成员变量和成员方法

方法:

super.成员变量
super.成员方法([参数1,参数2……])

注意:

  1. super不是引用类型,super中储存的不是内存地址。
  2. super代表的是当前子类对象中父类型特征。
  3. 子类和父类都有某个数据时,如果需要在子类中访问父类中的数据,需要使用super。
  4. super可以用在成员方法中,也可以用在构造方法中。
  5. super和this相同,都不能用在静态方法中。

使用super关键字调用父类的构造方法

方法:

super([参数1,参数2……])

注意:

  1. 通过super调用父类构造方法的代码必须位于子类构造方法的第一行,并且只能出现一次。
  2. 在子类的构造方法中一定会调用父类的某个构造方法,这时可以在子类的构造方法中通过super指定调用父类的哪个构造方法,如果没有指定,在实例化子类对象时,会自动调用父类无参的构造方法。
  3. 通过子类的构造方法去调用父类的构造方法,作用是给当前子类对象中的父类型特征赋值。
  4. super([参数1,参数2……])与this([参数1,参数2……])不能共存。

在java中,针对类、成员方法和属性提供了四种访问级别,分别是private、default、protected、public。这四种控制级别有小到大依次为:private--default--protected--public。

具体介绍如下:

private(类访问级别):如果类的成员被private访问控制符来修饰,则这个成员只能被该类的其他成员访问,其他类无法直接访问。类的良好封装就是通过private关键字来实现的。
default(包访问级别):默认修饰符,如果一个类或者类的成员不适用任何访问控制的修饰符修饰,则默认是default,这个类或者类的成员只能被本包中的类访问。
protected(子类访问级别):如果一个类的成员被protected访问控制符修饰,那么这个成员能被其所有子类访问(包括同一包下的子类,也包括不同包下的子类).
public(公共访问级别):这是一个最宽松的访问控制级别,如果一个类或者类的成员被public控制修饰符修饰,那么这个类或者类的成员能被所有的类访问。
访问控制级别表:

publicprotecteddefaultprivate
同一个类中
同一个包中
子类
不同包中

在程序开发过程中,需要将编写的类分目录存放便于管理为此引入了包(package)机制,程序可以通过声明包的方式对java类定义目录。

包的定义和使用

定义:通常把功能相同的类存放在相同的包中。在声明包时,使用package语句,具体示例如下:

package pkg1[.pkg2[.pkg3…]];
当编译一个声明了包的java源文件,需要使用命令生成与包名对应的目录,使用“-d”来指定生成的类文件的位置,可以用“.”来表示当前目录,也可写绝对路径,最终。class文件将存放于改目录下,如果该目录不存在,java虚拟机会帮你自动创建。具体示例如下:

javac -d [路径];
注意:

包的声明只能位于java源文件的第一行。

建立定包名不要重复,可以使用url来完成定义,url是唯一的。

java中包的命名规范:全小写字母拼写。

包机制的引入,可以对.class文件进行集中的管理。如果没有显式地声明package语句,类则处于默认包下。
包的定义示例:

 package com.sunxiaoning;
 public class HelloWorld
 {
     public static void main()
     {
         System.out.println("HelloWorld!!!");
     }
 }

使用:在程序开发中,位于不同包中的类会经常需要互相调用。调用时需要使用“包名.类名”的格式来调用,同意包中的类,包名可以省略。在实际开发中,定义的类都是包含包名的,而且还有可能定义很长的包名。为了简化代码,java中提供了import关键字,使用import可以在程序中一次导入某个指定包下的类,这样就不必在每次用到该类时都书写完整类名了,具体格式如下:

import 包名.类名;
注意:

import通常出现在package语句之后,类定义之前。
如果需要用到一个包的多个类时,则可以使用“import.包名.”的方式导入该包下的所有类。建议,不要写通配符 ,需要用到包中的哪个类,就导入哪个类。
jar包

在实际开发过程中,经常需要开发一些类供给别人使用,为了能更好地管理这些类,在JDK中提供了一个jar命令,使用这个命令能够将这些类打包成一个文件,这个文件的扩展名为.jar。它是一种压缩文件,独立于任何操作系统平台,习惯上也将jar文件称为jar包。在使用jar包时,只需要在classpath环境变量中包含这个这个jar文件的路径,java虚拟机就能够自动在内存中解压这个jar文件,根据包名所对应的目录结构去寻找所需要的类。
压缩jar文件

jar -cvf [jar包的名称].jar [需要压缩的文件名]
参数:

-c代表创建归档的文件
-v代表在标准输出中生成详细输出
-f代表指定归档文件名
解压

jar -xvf [jar包的名称].jar
java语言中常用包

java.lang : java的核心包 jdk1.2版本以后,该包中的类自动导入。
java.awt: 用于制作图形界面。
java.io:input output 用于操作设备上的数据。
java.util : 这里定义是java的工具类。集合,日期。
java.net:用于网络通讯的。

find命令

格式:find 搜索范围

搜索文件

find  / -name  install.log

避免大范围搜索,会非常耗费系统资源

find是在系统当中搜索符合条件的文件名。如果需要匹配,使用通配符匹配,通配符是完全匹配。

find  /root  –iname  install.log

不区分大小写

find  /root –user  root

按照所有者搜索

find  /root  –nouser

查找没有所有者的文件

find  /var/log/  -mtime  +10

查找10天前修改的文件

-10 10天内修改文件
10 10天当天修改的文件
+10 10天前修改的文件

atime 文件访问时间
ctime 改变文件属性
mtime 修改文件内容

find  -size  25k

查找文件大小是25kB的文件

-25 小于25kB的文件
25 等于25kB的文件
+25 大于25kB的文件

find  -inum  262422

查找i节点是262422的文件

find  /etc  -size  +20k  -a  -size  -50k

查找/etc/目录下,大于20kB并且小于50kB的文件

-a and 逻辑与,两个条件都满足
-o or 逻辑或,两个条件满足一个即可

find  /etc  –size  +20k  -a  -size  -50k  -exec  ls –lh {}\;

查找/etc/目录下,大于20k并且小于50k的文件,并显示详细信息

-exec/-ok命令{}\;对搜索结果执行操作

搜索字符串命令grep

格式:grep [选项] 字符串 文件名

在文件当中匹配符合条件的字符串

选项:

-i  忽略大小写
-v  排除指定字符串

find命令与grep命令的区别

find命令:在系统当中搜索符合条件的文件名,如果需要匹配,使用通配符匹配,通配符是完全匹配。
grep命令:在文件当中搜索符合条件的字符串,如果需要匹配,使用正则表达式进行匹配,正则表达式时包含匹配。

由于ubtun系统默认是没有激活root用户的,提示 Authentication failure说明还没有激活root用户,需要我们自己手工进行操作,激活root用户需要在命令行界面下,或者在终端中输入如下命令:

sudo passwd

系统会显示:Password:(输入你当前用户的密码 )

系统会显示:Enter new UNIX password:(重新设置的root的密码 )

系统会显示:Retype new UNIX password:(重复root的密码 )

成功之后就可以使用了。

shutdown命令

[root@localhost~]#shutdown [选项] 时间

选项:

-c:取消前一个关机命令
-h:关机
-r:重启

其他关机命令

[root@localhost~]#halt
[root@localhost~]#poweroff
[root@localhost~]#init 0

其他重启命令

[root@localhost~]# reboot
[root@localhost~]# init 6

系统运行级别

0 关机
1 单用户
2 不完全多用户,不含NFS服务
3 完全多用户
4 未分配
5 图形界面
6 重启

[root@localhost~]# cat/etc/inittab

修改系统默认运行级别

Id:3:initdefault:
[root@localhost~]# runlevel

退出登录命令

[root@localhost~]# logout

为了保存数目不确定的对象,JDK中提供了一系列特殊的类,这写类可以存储任意类型的对象,并且长度可变,统称为集合。这些类都位于util包中,使用的时候一定要注意导包的问题,否则会出现异常。
集合按照其存储结构可以分为两大类,即单列集合(Collection)和双列集合(Map)。体系结构(常用的类和接口):

Collection:单列集合类的跟接口,用于存储一系列符合某种规则的元素。
    |--List:Collection的子接口,特点是元素有序,元素可重复。
        |--ArrayList:List的接口的一个实现类,ArrayList内部封装了一个长度可变的数组对象,当存入的元素超过数组长度时,ArrayList会在内部中分配一个更大的数组来存储这些元素,因此可将ArrayList集合看做一个长度可变的数组。查询效率较高。
        |--LinkedList:List集合的一个实现类,该集合内部维护了一个双向循环列表,链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素,从而可以将所有的元素彼此连接起来。增删效率较高。
    |--Set:Collection的子接口,特点是元素无序,并且不可重复。
        |--HashSet:Set接口的实现类,HashSet底层实际上是一个HashMap,HashSet其实是HashMap中的Key的部分。
        |--TreeSet:Set接口的实现类,内部采用自平衡的排序二叉树来存储元素,这样结构可以保证TreeSet集合中没有重复的元素,并且可以对元素进行排序。
Map:双列集合类的根接口,用于存储键(Key)、值(Value)映射关系的元素,每个元素都包含一对键值。
    |--HashMap:Map的实现类,它用于存储键值映射关系,但必须保证不出现重复的键,键相同,值覆盖。
    |--TreeMap:Map的实现类,它也用于存储键值映射关系,但必须保证不出现重复的键。在TreeMap中是通过二叉树的原理保证键的唯一性,这与TreeSet集合的存储原理一样,因此TreeMap中所有的键是按照某顺序排列的。

注:元素有序是指存入数据的数据和取出数据的顺序是一致的。

自定义异常

在实际开发中,因为项目中会出现特有的问题,而这些问题并未被java所描述并封装对象,所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题,进行自定义的异常封装。自定义异常类必须继承自Exception或其子类。
在实际开发中,如果没有特殊的要求,自定义异常类只需要继承Exception类,在构造方法中使用super()语句,调用Exception的构造方法即可。自定义异常时,如果该异常的发生,无法在继续进行运算,就让自定义异常继承RuntimeException。
自定义了异常后,需要用到throw关键字,throw关键字用于在方法中声明抛出异常的实例对象,其语法格式如下:

throw Exception 异常对象
定义类继承Exception或者RuntimeException

为了让该自定义类具备可抛性。
让该类具备操作异常的共性方法。
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。

class MyException extends Exception
    {
        MyException(String message)
        {
            super(message);
        }
    }

自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。

继承Exception原因

异常体系有一个特点:因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别

throws使用在函数上。throw使用在函数内。
throws后面跟的异常类。可以跟多个,用逗号隔开。throw后跟的是异常对象。
注:当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,都在编译失败。RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
异常在子父类覆盖中的体现

1.子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。
2.如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。
3.如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理,绝对不能抛。

异常处理办法

try……catch和finally

java中,由于发生了异常,程序立即终止,无法继续向下执行。为了解决这样的问题,java中提供了一种对异常进行处理的方式————异常捕获。异常捕获通常使用try……catch语句。
语法:

try
{
    需要被检测的代码;
}
catch(异常类 变量)
{
    处理异常的代码;(处理方式)
}
finally
{
    一定会执行的语句;
}

注:

try代码块中编写可能发生异常的java语句,catch代码块中编写针对异常进行处理的代码。当try代码块中的程序发生了异常,系统会将这个异常的信息封装成一个异常对象,并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能够接收的异常类型,这个参数的类型必须是Exception类或其子类。
在try代码块中,发生异常语句后面的代码块是不会被执行的。
建立在进行catch处理时,catch中一定要定义具体处理方式。
finally中的语句是一定会执行的,通常用于关闭资源。除了在try……catch中执行了System.exit(0)语句。System.exit(0)表示退出当前的java虚拟机,java虚拟机停止了,任何代码都不能再执行了。
catch是用于处理异常。如果没有catch就代表异常没有被处理过,如果该异常是检测时异常。那么必须声明。
throws关键字

java中允许在方法的后面使用throws关键字对外声明该方法有可能发生异常,这样调用者在调用方法时就明确知道该方法有异常,并且必须在程序中对异常进行处理,否则编译无法通过。
语法:

修饰符 返回值类型 方法名([参数1,参数2……]) throws ExceptionType1[,ExceptionType2……]{}
注:

使用throws处理异常并不是真正的处理异常,而是推卸责任,谁调用就会抛给谁。
便于提高安全性,让调用出进行处理。不处理编译失败。
对多异常的处理

1.声明异常时,建议声明更为具体的异常。这样处理的可以更具体。
2.对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。catch必须从上到下,从小到大捕捉。