【程序员必备】java重要基础常用知识

 

SDK（软件开发工具包）：一般都是一些软件工程师为特定的软件包、软件框架、硬件平台、操作系统等建立应用软件时的开发工具的集合

（广义上指辅助开发某一类软件的相关文档、范例和工具的集合）

API（应用编程接口）：就是操作系统留给应用的一个调用接口，应用程序通过调用操作系统的API而使操作系统去执行应用程序的命令

                                          JAVA基础知识

对象：人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象具有状态，一个对象用数据值来描述它的状态，对象还有操作，用于改变对象的状态。对象实现了数据和操作的结合，使数据和操作封装与对象的统一一体中。

类：具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类。类的具体化就是对象。也可以说类的实例是对象。类实际上就是一种数据类型。类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。类具有操作，它是对象的行为的抽象，用操作和实现该操作的方法来描述。

特征：对象都有自身唯一的标识。抽象性：抽象性是指将具有一制的数据结构（属性）和行为（操作）的对象抽象成类。继承性：继承性是子类自动共享父类数据结构和方法的机制。

JAVA访问修饰符

访问级别	访问控制修饰符	同类	同包	子类	不同的包
公开	public	√	√	√	√
受保护	protected	√	√	√	——
默认	没有访问修饰符	√	√	——	——
私有	private	√	——	——	——

重要总结：通过上面的分析，我们可以看到：

　　 1. public、private和protected对我们来说没有任何异议。

　　 2. 顶层类只能用public访问修饰符和default（默认）访问修饰符修饰，其中用默认修饰符修饰的类（及没有任何修饰符的类，如class B{}）不能被其他包中的类继承，这也说明了default（默认）访问修饰符突出的是包权限

　　 3. protected：本人做了一次实验，发现在不同包的子类中，new一个父类对象，并用该父类对象去访问父类中的用protected修饰的类属变量和方法时不能访问，而new一个子类对象时，子类对象可以访问（说明protected修饰的类可以被其他包中的类继承）。也可以在子类重写父类的方法中使用super关键字调用。这岂不是和上面表格中的总结（红色对勾）冲突了？本人也是百思不得其解。最后在网上找到了一个相对比较认可的解释，如下：　　　　

　　protected修饰符的修饰的成员变量和方法也称为受保护的成员变量和方法， 受保护的成员变量和方法可以在本类或同一个包中的其它类（包括子类）中通过类的实例进行访问，也可以被同一个包中的类或不同包中的类继承，但是不能在不同包中的其它类（包括子类）中通过类的实例进行访问。

 　　4. 如果一个类使用public修饰，那该类的类名必须与他所在的源文件名相同。一个.java源文件中有且只有一个public类，顶层类只能用public和默认修饰符（即无修饰符）修饰；

　　5. final修饰的类不能被继承，没有子类。

　　6. abstract修饰的类不能被实例化，必须被子类继承。类只要有一个抽象方法就必定是抽象类，但抽象类不一定要有抽象方法。

最终总结，就一句话：protected修饰符所修饰的类（这句话中指父类）属成员变量和方法，只可以被子类访问，而不管子类是不是和父类位于同一个包中。default修饰符所修饰的类属成员变量和方法，只可被同一个包中的其他类访问，而不管其他类是不是该类的子类。protected属于子类限制修饰符，而default属于包限制修饰符。

JAVA常用关键字

1.this和super

         this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。

用法：

class test{
String str；
public  test（String str）
{
     this.str=str；
}

}

            super与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。

用法：

class Country {
    String name;
    void value() {
       name = "China";
    }
}
  
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
    }
  
    public static void main(String[] args) {
       City c=new City();
       c.value();
       }
}

注意：super不能在静态方法中使用。super（）必须放在子类的构造方法中使用；

2.方法重写

方法的访问修饰符和返回值，参数类型，个数，顺序都要与父类相同；

（重写方法后会用自己类的方法，不会再用父类的方法）

3.final关键字

final 类：该类不能被继承；

final方法：该方法不能被子类重写；

final变量：

.1.方法内的局部变量：只要在具体被使用之前 进行赋值即可，一旦赋值不允许被修改。
2.类中的成员属性：赋值只能在三个位置：1、定义直接初始化 2、构造方法 3、构造代码块

4.单例模式

要点：某个类只能有一个实例，必须自行创建实例。必须向整个系统提供这个实例。

实现：1.只提供私有的构造方法

2.含有一个该类的静态私有对象

3.提供一个静态的公有方法用于创建、和获取静态私有对象。

好处：只有一个实例，可以节省内存。一般数据初始化等配置工作可以使用。

饿汉式单例
public class fash{
private  fash（）
{}

private static fash fs=new fash;


public static fash getInstans()
{

retunrn  fash}

}
懒汉式单例
public class fash1{
private  fash1（）
{}

private static fash1 fs =new fash1;


public static fash1 getInstans()
{
if（fash1==null）
{
fash1=new fash1
}
retunrn  fash}

}

5、instanceof关键字

instanceof作用是判断其左边对象是否为其右边类的实例

6、类&抽象类

静态内部类：静态内部类可以通过对象访问外类的非静态成员和方法。可以直接访问静态类和方法；

非静态内部类：可以直接访问外部类的所有属性和方法；

内部类的实例实现：

静态&非静态内部类（实例）：

静态内部类实例的实现
config.configtura cft=new config.configtura;

非静态内部类实例的实现

config c=new config；
config.configtura cft=c.new configtura；

内部类的使用好处：可以实现多继承（一个类只可以继承一个父类），可以将外部类的访问权限降到最低可以使用private；

父类对象=子类对象；向上转型；子类对象=父类对象；向下转型；由右向左。向下转型，进行强制转换

注：随机产生数字0到1；方法Math.random()

抽象方法：包含抽象方法必须是抽象类，抽象类可以没有抽象方法；抽象类是为了抽象方法；抽象方法必须是public；因为final不允许被重写；静态也是不能被重写的，

抽象方法：不能有方法体，子类必须重新父类的抽象方法;除非把子类变成抽象类；
使用价值：就是没有必要在父类实现，其他子类必须都要有这样的抽象方法

7、接口（interface）

接口： 用于提取不冋类的共同方法

interface usb{
void useusb（）；
}

class usbtool implement usb
{
实现接口方法
public void useusb（）{


}
}

类： 用于提取不同对象的共同属性和方法

接口回调使用

interface answer 
{
 void oncall（String s）；

}
//回调方：需要定义接口对象，对外设置listen方法
class A{
public String s；
answer as=new answer;

public void call{

System.out.print("这个题目怎么写")；
as.oncall（s）；
}

public void oncalllisten（answer as）

{


this.as=as}；

}
//接口实现方。接口实现后回调到对象中进行处理
class B{

A a=new A；

A.oncalllisten(new as

{
public void oncall(String s) //这里的String 等于就是class call的String
{
System.out.print("这道题等于B")
}
})

}

8、异常try{}cath{}final{}&throw

try{代码块}，cath{}捕获代码块是否有异常，抛出异常，final{无论代码块是否有异常都将执行}

多重cath不能出现相同异常。

9、Stringbuild，Arraylist,Hashmap

Stringbuild 字符串包装。常用方法，append【后位添加字符】，replace【替换字符】

 List（序列），Queue（队列）有序，允许重复   set无序不允许重复

ArrayList 长度动态增长的数组  ArrayList 可以存null 适合查找和更新元素。

ArrayList具有添加，存储字符串和类。修改，删除；长度使用size（）;有序可以重复;add()添加；remov（）删除；set()修改方法；add(int intdex,e)插入

HashMap 键值对的Key获取元素。

10. 多线程Thread

每个工作都有每个线程去完成，例如我们的电脑都是由多个线程完成的，比如一边看电视，一边听音乐。

需要实现Runbable接口；

Thread的常用方法有：join（），sleep（）。wait（）。notify（）。

join（），优先执行该线程，sleep（）线程休眠，线程休眠多久后再执行该线程。

wait（），中断线程执行，使线程处于等待的状态，notify唤醒等待线程，使其结束等待，notifyall（）唤醒所有处于等待的线程。

线程同步：使用关键字synchronized加锁，synchronized可以使用在成员方法，静态方法，语句块，防止线程在执行完之前被打断。

11、File&输入和输出

File： new File("路径")；

相对路径：无盘符的路径。绝对路径：有盘符的路径

常用方法：isDirectory(),判断是否为目录。isFile判断是否为文件。  

如果isDirectory()为false 使用 .mkdirs（）创建目录；如果isFile为false使用.createNewFile创建文件

文件字节输入流（读）：

FileInputStream 文件输入字节流 从系统中文件获得字节。一般读取如图像数据之类的原始字节流

int read（）从输入中读取一个字节流。int read(byte[] b) 字节的数据读入到一个byte数组中，close（）关闭文件输入流并释放与此流有关的所有系统资源。注意  int 返回值为-1 表示文件读到了末尾。

常用文件字节输出流（写）

FileOutputstrem

new FileOutputstrem（“路径”，false/true）true 不覆盖文件内容在末尾添加内容 

write（）将指定文件写入文件的输出流 write（byte[]）将byte所有数据写入到文件当中。

常用字符输入流（读）

BufferedRead 缓冲字符输入流 InputStreamRead 字节和字符的转换流

InputStreamRead使用：

FileInputStream fis=new FileInputstream("hello.text");

InputStreamRead isr=new InputStreamRead(fis);
char[] c=new char[10];
int n=0;
while((n=isr.read())!=-1)
{

System.out.print((char)n+"");

}

或者while（（n=isr.read(c))!=-1）
{
String str=new String(c,0,n);
System.out.print(str+"");
}

outputStreamWrite 使用方法同上。