标签 java 下的文章

在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:用于网络通讯的。

为了保存数目不确定的对象,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必须从上到下,从小到大捕捉。

java中的异常都是类,在异常对象中会携带一些信息给我们,我们通过这个异常对象将信息提取出来

异常体系

Throwable
    |--Error
                |--IOError
                |--AWTError
                |--其他子类
    |--Exception
        |--RuntimeException
                    |--ArithmeticException
                    |--ClassCastException
                    |--其他子类
                |--其他子类

Throwable
    |--Error
                |--IOError
                |--AWTError
                |--其他子类
    |--Exception
        |--RuntimeException
                    |--ArithmeticException
                    |--ClassCastException
                    |--其他子类
                |--其他子类

异常体系的特点

1.异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。
2.Error是java程序运行过程中出现了错误,错误是不能够处理,只能退出JVM。
3.Exception是可以处理的。如果没有处理异常,则程序直接退出JVM。
4.编译时异常:所有的Exception的直接子类都是“编译时异常”。

异常的分类

编译时异常:编译时被检测异常,该异常在编译时,如果没有处理(没有抛也没有try),编译失败。该异常被标识,代表这可以被处理。Exception类中除了RuntimeException类及其子类都是编译时异常。
运行时异常(编译时不检测):在编译时,不需要处理,编译器不检查。该异常的发生,建议不处理,让程序停止。需要对代码进行修正。RuntimeException类及其子类都是运行时异常。如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过;之所以不用在函数声明,是因为不需要让调用者处理。当该异常发生,希望程序停止。因为在运行时,出现了无法继续运算的情况,希望停止程序后,对代码进行修正。
异常的处理原则

处理方式有两种:try 或者 throws。

调用到抛出异常的功能时,抛出几个,就处理几个。一个try对应多个catch。

多个catch,父类的catch放到最下面。

catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写。

当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。

try
{
    throw new AException();
}
catch (AException e)
{
    throw e;
}

如果该异常处理不了,但并不属于该功能出现的异常。

可以将异常转换后,在抛出和该功能相关的异常。或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,当调用者知道。并处理。也可以将捕获异常处理后,转换新的异常。

try
{
    throw new AException();
}
catch (AException e)
{
    // 对AException处理。
    throw new BException();
}

异常的注意事项

在子父类覆盖时:

子类抛出的异常必须是父类的异常的子类或者子集。
如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
异常的好处

将问题进行封装。
将正常流程代码和问题处理代码相分离,方便于阅读。

由于字符串是常量,因此一旦被创建,其内容和长度是不可改变的。如果需要对一个字符串进行修改,则只能创建新的字符串。为了便于对字符串的修改,在JDK中提供了一个StringBuffer类(也称字符串缓冲区)。StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类,类似一个容器,当在其中添加或删除字符时,并不会产生新的StringBuffer对象。

StringNuffer类的特点

长度是可变化的。
可以字节操作多个数据类型。
最终会通过toString方法变成字符串。
StringBuffer类的常用方法

存储
StringBuffer append(char c) 将指定数据作为参数添加到已有数据结尾处
StringBuffer insert(int offset,String str) 将字符串中的offset位置插入字符串str
删除
StringBuffer delete(int start,int end) 删除StringBuffer对象中指定范围的字符或字符串序列(包含start,不包含end)。
Stringbuffer deleteCharAt(int index) 移除次序列指定位置的字符
获取
char charAt(int index) 获取指定位置的字符
int indexOf(String str) 获取指定字符串的位置
int lastIndexOf(String str) 获取指定字符串最后一次出现的位置
int length() 获取字符串的长度
String substring(int start, int end) 获取指定位置的字符串
修改
StringBuffer replace(int start,int end,String s) 在StringBuffer对象中替换指定的字符或字符串序列(包括star不包括end)
void setCharAt(int index,char ch) 修改指定位置index处的字符序列
反转
StringBuffer reverse() 将此字符串序列用其反转形式取代
注意:JDK1.5 版本之后出现了StringBuilder,StringBuffer是线程同步。,StringBuilder是线程不同步,以后开发,建议使用StringBuilder。

代码示例:

public class StringBufferDemo {
    public static void main(String [] args) {
        sop("添加");
        add();
        sop("删除");
        delete();
        sop("获取");
        select();
        sop("修改");
        alert();
    }
    public static void add() {
        StringBuffer sb = new StringBuffer();
        sb.append("dddddd");
        sop("在末尾处添加:"+sb);
        sb.insert(2,"12");
        sop("在第二个位置添加12:"+sb);
    }
    public static void delete() {
        StringBuffer sb = new StringBuffer("abcdefghigklmn");
        sb.delete(0,2);
        sop("删除0到2位置的"+sb);
        sb.deleteCharAt(3);
        sop("删除第3个位置的字符"+sb);
    }
    public static void select() {
        StringBuffer sb = new StringBuffer("abcdefghigak");
        sop("获取下标为2的字符"+sb.charAt(2));
        sop("获取字符e的下标"+sb.indexOf("e"));
        sop("获取a最后一次出现的下标"+sb.lastIndexOf("a"));
        sop("获取字符串的长度"+sb.length());
        sop("获取1到3位置的字符串"+sb.substring(1,3));
    }
    public static void alert() {
        StringBuffer sb = new StringBuffer("abcdefghigkl");
        sop("修改1到3位置上的字符串为zz:"+sb.replace(1, 3, "zz"));
        sb.setCharAt(5,'r');
        sop("修改5位置上的字符为r:"+sb);
        sop("反转"+sb.reverse());
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

在程序中经常会用到字符串,在java中定义了String和StringBuffer两给类来封装字符串,并提供了一系列操纵字符串的方法,它们都位于java.lang包中,因此不需要导包就可以直接使用。String类是不可变类,也就是说String对象声明后,将不可修改(可以理解为字符串一旦创建就不可以修改)。

String的初始化

1.使用字符串常量直接初始化一个String|对象。
String [变量名] = "变量值";
2.使用String的构造方法初始化字符串对象
String() 创建一个内容为空的字符串
String(char[] value) 根据指定的字符数组创建对象。
String(String value) 根据指定的字符串内容创建对象
代码示例:

public class StringDemo1 {
    public static void main(String [] args) {
        String str1 = "sunxiaoning";//使用字符串常量直接初始化一个String|对象。
        String str2 = new String();//创建一个内容为空的字符串
        char ch[] = {'s','x','n'};
        String str3 = new String(ch);//根据指定的字符数组创建对象。
        String str4 = new String("sunxiaoning");//根据指定的字符串内容创建对象
        //打印字符串
        sop(str1);
        sop(str2);
        sop(str3);
        sop(str4);
    }
    /*
     * 打印函数
     * */
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

String的常见操作

1.获取

int length() 返回此字符串的长度

char charAt(int index) 根据位置获取位置上某个字符。

int indexOf(int ch) 返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch, int fromIndex) 从fromIndex指定位置开始,获取ch在字符串中出现的位置。

int indexOf(String str) 返回的是str在字符串中第一次出现的位置。

int indexOf(String str, int fromIndex) 从fromIndex指定位置开始,获取str在字符串中出现的位置。

int lastIndexOf(int ch) 返回此字符在此字符串中最后一次出现处的索引
代码演示:

public class StringDemo2 {
    public static void main(String [] args) {
        String str = "aabbccddeeff";
        sop("字符串的长度为"+str.length());
        sop("下标为5的字符是"+str.charAt(5));
        sop("第一次出现c的位置是"+str.indexOf('c'));
        sop("从第六个位置数,出现c的位置是"+str.indexOf('d',6));
        sop("第一次出现字符串cc的位置是"+str.indexOf("dd"));
        sop("最后一次出现cc的位置是"+str.lastIndexOf("cc"));
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

2.判断

boolean contains(CharSequence cs) 判断此字符串中是否包含指定的字符序列

boolean isEmpty() 判断字符中是否有内容,原理就是判断长度是否为0,当且仅当字符串长度为0时返回true

boolean startsWith(String prefix) 判断此字符串是否以指定的字符串开始

boolean endsWith(String suffix) 判断此字符串是否以指定的字符串结尾

boolean equals(Object anObject) 将此字符串与指定字符串比较,判断字符串内容是否相同,复写了Object类中的equals方法。

boolean equalsIgnoreCase(String anotherString) 判断内容是否相同,并忽略大小写。
代码示例

public class StringDemo3 {
    public static void main(String []args) {
        String str1 = "aaaabbbbb";
        String str2 = "aabbcc";
        String str3 = "aAbbcc";
        sop("str1中是否包含aa"+str1.contains("aa"));
        sop("Str1的长度为0吗"+str1.isEmpty());
        sop("str1是以cc开头吗"+str1.startsWith("cc"));
        sop("str1是以bb结尾吗"+str1.endsWith("bb"));
        sop("str1的内容与str2相同吗"+str1.equals(str2));
        sop("str2的内容与str3相同吗(忽略大小写)"+str2.equalsIgnoreCase(str3));
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

注意:indexOf(str):可以索引str第一次出现位置,如果返回-1.表示该str不在字符串中存在。所以,也可以用于对指定判断是否包含。而且该方法即可以判断,有可以获取出现的位置。

3.转换

将字符数组转成字符串
构造方法
String(char[])
String(char[],offset,count) 将字符数组中的一部分转成字符串。
静态方法
static String copyValueOf(char[])
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[])
将字符串转成字符数组
-char[] toCharArray()
将字节数组转成字符串
String(byte[])
String(byte[],offset,count) 将字节数组中的一部分转成字符串
将字符串转成字节数组
byte[] getBytes()
将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)
4.替换

String replace(oldchar,newchar) 将字符串中的oldchar替换成newchar
5.切割

String[] split(String regex) 根据参数regex将原来的字符串分割为若干子串
6.子串。获取字符串中的一部分。

String substring(int beginIndex) 返回一个新字符串,它包含字符串索引beginIndex后的所有字符。
String substring(int beginIndex,int endIndex) 返回一个新字符串,它包含此字符串中索引beginIndex到索引endindex之间的所有字符。
7.将字符串转成大写或则小写

String toUpperCase() 将字符串转成大写
String toLowerCase() 将字符串转成小写
8.将字符串两端的多个空格去除

String trim();
9.对两个字符串进行自然顺序的比较

int compareTo(string);

第一步:下载jdk

大家可以从官网上下载jdk(http://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.html),国外的网站,可能有点慢,所以小编为大家准备了另外的方式

大家可以关注小编的公众号(小宁博客),回复"jdk8"获得jdk8,想安装jdk7的话就回复“jdk7”,

小编的公众号名字也是小宁博客,大家可以关注一下哦。

第二步:安装jdk

首先:安装javaSE

根据提示,点击下一步按钮,直到安装完成。
2452175439.png

可以更改安装位置
651219736.png
3260324719.png
安装完成
2871547568.png

第三步,配置配置JAVA环境变量

1.右击此电脑,选择“属性”
2.选择“高级系统设置”
1121385247.png

3.选择“高级”,然后选择“环境变量”

2444838542.png
4.选择“新建”
2313990523.png
5.新建系统变量JAVA_HOME
变量名:JAVA_HOME
变量值:C:\\Program Files (x86)\Java\jdk1.8.0_45\JDK(jdk的安装路径)
1107909937.png

6.新建系统变量CLASSPATH(初学者可以不配置)
变量名:CLASSPATH
变量值:.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
447904405.png

7.选择系统变量中变量名为“Path”的环境变量,win10中可以直接新建,插入一条记录。
变量名:Path
变量值:%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
627744927.png

点击确认,保存退出,完成。

8.点击“win+R“,在运行窗口里输入“cmd“

2261601238.png
9.回车后,在dos窗口里,输入“javac“

3854793108.png
显示上述画面,则安装与配置成功。

逻辑运算符

& AND(与),左右全为真时,结果才为真,其余为假
| OR(或),左右全为假时,结果才为假,其余为真
^ XOR(异或),左右相同时为假,左右不相同时为真
! NOT(非),取反
&& AND(短路),同&
|| OR(短路),同I
“&”和“&&”的区别:

  • 单&时,左边无论真假,右边都进行运算;
  • 双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算。
    “|”和“||”的区别同理,双或时,左边为真,右边不参与运算。
    异或( ^ )与或( | )的不同之处:当左右都为true时,结果为false。

位运算符

  • “<<”,左移, 空位补0,被移除的高位丢弃,空缺位补0。 比如:3 << 2 = 12 ‐‐> 322=12
  • “>>”,右移,被移位的二进制最高位是0,右移后,空缺位补0;最高位是1,空缺位补1。比如:3 >> 1 = 1 ‐‐> 3/2=1
  • ">>>",无符号右移,被移位二进制最高位无论是0或者是1,空缺位都用0补。比如:3 >>> 1 = 1 ‐‐> 3/2=1
  • "&",与运算,二进制位进行&运算,只有1&1时结果是1,否则是0。比如:6 & 3 = 2
  • "|",或运算,二进制位进行 | 运算,只有0 | 0时结果是0,否则是1。比如: 6 | 3 = 7
  • "^",异或运算,任何相同二进制位进行 ^ 运算,结果是0; 1^1=0 , 0^0=0;不相同二进制位 ^ 运算结果是1。比如:1^0=1 , 0^1=1。 6 ^ 3 = 5
  • "~",反码,各位取反,结果为原来数的相反数-1.比如: ~6 = ‐7

交换两个变量值的方式

方法一:通过第三方变量(一般使用该方法)。
int temp;
temp = n;
n = m;
m = temp;
方法二:不用第三方变量
n = n + m;//如果n和m的值非常大,容易超出int范围。
m = n - m;
n = n - m;
方法三:异或的方法
n = n ^ m;
m = n ^ m;//(n^m)^m;
n = n ^ m;//n ^ (n ^ m)