java学习笔记

1 安装配置

首先下载jdk，https://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html官网下载，最新版安装它是不会在帮你下载jre的。安装完成之后（安装就和一般安装软件一样，这里主要就是讲环境配置）

安装完成之后，右键点击此电脑，点击属性，点击高级系统设置，点击环境变量。配置看这里
https://blog.csdn.net/songxiaolingbaobao/article/details/89914683
最后验证你是否配置成功，按win+r，输入cmd，在面板中输入javac.

2 基本知识

JDK ： development kit
JRE ：runtime environment
JVM： virtual machine
EE　enterprise　edition
SE　standard　 edition　
ME micro edition
JAVA面向对象编程 类的概念十分重要
类加载器是有层次的

一般是： 自定义类加载器 >> 应用程序类加载器 >> 扩展类加载器 >> 启动类加载器

上面的层次关系被称为双亲委派模型(Parents Delegation Model)。除了最顶层的启动类加载器外，其余的类加载器都有对应的父类加载器。再简单说下双亲委托机制：如果一个类加载器收到了类加载的请求，它首先不会自己尝试去加载这个类，而是把这个请求委派给父类加载器，每一个层次的类加载器都是加此，因此所有的加载请求最终到达顶层的启动类加载器，只有当父类加载器反馈自己无法完成加载请求时（指它的搜索范围没有找到所需的类），子类加载器才会尝试自己去加载。

只有一个public类
文件名要和public类名称一致

运行方法 ：
javac xxx.java 编译生成 xxx.class
java xxx 运行 注意是 xx不是xxx.class

3 语法

3.1 变量

变量函数名不可数字开头 严格区分大小写！ 比如 System S要大写 String S要大写

变量： final就是的const ，变量是类或者结构里的字段，初始化没有无关。但是方法中的变量一定要初始化。

3.2 运算

&和&&的区别：1&&只要第一个条件不满足，后面条件就不再判断。而&要对所有的条件都进行判断。
| 和||同理
2 &和|是按位与/或 &&和||是逻辑与逻辑或

三元运算符

   z = (x>y)?x:y ;

等同于
if x>y
z=x
else
z=y
三元运算符和if else的区别在于 三元运算符要有值出现，而if else不用

计算顺序：
+正号、-负号 ＞ 乘号*、除号/、取余数符号% ＞ 加号+、减号-

3.3 流程控制语句:

判断结构 if
选择结构 switch
循环结构 while for
1.
while(){
xxxxx;
}

do{
xxxx;
}while();

do while 优点 无论条件满足与否 都至少执行一次循环体
2.
for（初始化表达式；循环条件；循环后的操作）{
xxx;
}
ps:无限循环 while(true) for( ;; )
for的变量循环一次会释放 while不会

3.4 字符和字符串 ，数组

stirng类一旦创建不可以修改 修改是返回新string
要频繁修复字符串用 stringbuffer

数组
int[] arr=new int[5] ;
int[] array=new int[5] {1,2,3,2,1} ;
int[] array={1,2,3,2,1} ;
栈stack和堆heap

栈是一级缓存，系统自动释放。 堆是二级缓存，一般程序员自己释放，必要时候系统会释放。

4 对象和类

4.1 对象和类的概念，特点

面向对象的特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

类的三个特性：
抽象性、
封装性、
隐藏性

// father class


public class HelloWorld {
    String name;
    int num;
    public HelloWorld(String name,int num){  // Constructor
        this.name = name;
        this.num = num;
        System.out.println(this.name);
}

    public void eat(String name){
        System.out.println(name+ " is walking ");
        
}

    public static void main(String []args) {
       System.out.println("Hello World!");
       int a=42;
       System.out.println("a 非的结果是："+(~a));
       HelloWorld world= new HelloWorld ("yejj", 23);
        world.eat("jingjing");
        System.out.println("ID"+world.num);
      
    }
}

void 和 static void的区别  在于static可以直接 类.方法调用

4.2 关键字 static public private final

public：放在堆内存 不会自己释放 成员变量 member variables
private：放在栈内存 会自动释放 局部变量 local variables
static：
静态方法只能访问静态成员
静态方法中不可以写this，super关键字
主函数是静态的

final:
可以修饰类，方法，变量，属性或局部变量
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。

4.3 构造方法（构造函数）和方法（函数）

构造方法：
方法名与类名相同
不用定义返回值类型
不可以写return语句
作用：
给对象进行初始化。
注意：
每个类都有构造方法。
多个构造函数是以重载的形式存在的。

class person {
    public static void prt(String s){
        System.out.println(s);
    }

    person(){
        prt("父第一类构造方法");
    }
    person(String s){
        prt("父第二类构造方法"+ "   " + s );
    }
}

public class chinese extends person{
    chinese(){
    super(); //调用父类的构造方法 
    }
    chinese(String name){
        super(name); //调用同参数构造方法
        prt("1111111");
    }

    chinese(String s ,int age){
    this (s);
    prt("00000");}

    public static void main(String[] args){
        chinese cn = new chinese();
        cn = new chinese("cassie");
        cn = new chinese("cassie",18);}
// 创立了一个类,那个类是什么对象之后可以改
      
}

4.3.1 this和super
this 指向当前类或对象

super代表父类的内存空间的标识
见上例子

4.3.2 子类的实例化 见上例子
子类中所有的构造函数默认都会访问父类中空参数的构造函数
因为每一个构造函数的第一行都有一条默认的语句super();
子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数

4.3.2 overload 方法重载和override方法重写
重载 方法重载
重写 子类对父类的重写

public class Findareas{
    public static void main(String []agrs){
        Figure f= new Figure(10 , 10);
        Rectangle r= new Rectangle(9 , 5);
        Figure figref;
        figref=f;
        System.out.println("Area is :"+figref.area());
        figref=r;
        System.out.println("Area is :"+figref.area());
    }
}
class Figure{
    double dim1;
    double dim2;
    Figure(double a , double b) {
        dim1=a;
        dim2=b;
    }
    Double area() {
        System.out.println("Inside area for figure.");
        return(dim1*dim2);
    }
}
class Rectangle extends Figure {
    Rectangle(double a, double b) {
        super(a ,b);
    }
    Double area() {
        System.out.println("Inside area for rectangle.");
        return(dim1+dim2);
    }
}

4.4 继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
public class SubDemo extends Demo{}
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。如果没有声明父类，则默认的父类为java.lang.Object
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2…//error
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
构造方法不能被继承
方法和属性可以被继承
子类的构造方法隐含的调用父类的默认构造方法
如果父类中没有默认的构造方法，则应该在子类的构造方法的第一行明确的声明调用父类中其他的构造方法。

4.5 多态 polymiorphism

两种多态
重载式多态，也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道，方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。

重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。 编译时候是父类 运行是子类

public class polymiorphism {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat  ？？
       a.eat();  // 测试是否可以调用运行时对象的方法
      Cat c = (Cat)a;        // 向下转型     (cat) 把a转成cat类 本来是animal类里面的cat对象
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

一个很好的关于向上向下转型的 网址 https://baijiahao.baidu.com/s?id=1617076999224722021&wfr=spider&for=pc点这里

4.5.1 抽象
抽象定义：
抽象就是从多个事物中将共性的，本质的内容抽取出来。
例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。
抽象类：
Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象方法的由来：
多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型 函数名(参数列表) ;
抽象类**不可以被实例化，也就是不可以用new创建对象。

4.6 接口

接口的字段定义默认为:public static final, 抽象类字段默认是”friendly”

格式：
interface {}
接口中的成员修饰符是固定的。
成员常量：public static final
成员函数：public abstract
发现接口中的成员都是public的。
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性。
接口可以用来多实现。
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系

一个java文件可以写多个类和接口在里面，但必须只能且必须有一个public的类或接口，而且那个public的类或接口必须和文件同名

extends 继承类 接口和接口之间继承；
implements 实现接口。
一个.java里面可以有多个接口和类
但是一个.java里面一定只能有一个 public （不可以同时一个public接口 一个public类）

> public class printerDemo{
    public static void main(String[] args) {
        ColorPrinter cp = new ColorPrinter("惠普");
        BlackPrinter bp = new BlackPrinter("联想");
        Teacher teacher = new Teacher("张三",26);
        School school = new School();
         
        school.setPrinter(cp);
        school.setPrinter(bp);
         
        school.print(school);
        school.print(teacher);
         
        bp.print("abc");
        cp.print("abc");
    }
}
 
class School implements IInfo{
    private Printer p = null;
    public void setPrinter(Printer p) {
        this.p = p;
    }
         
    public void print(IInfo info) {
        p.print(info.detail());
    }
     
    public String detail() {
        return "我是学校";
    }
}

 
interface IInfo{//接口，教师和学校都有的方法
    String detail();
}
 

abstract class Printer{
    private String brand;
    public String getBrand() {
        return brand;
    }

    public Printer(String brand) {//构造方法
        this.brand = brand;
    }
     
    public abstract void print(String content) ;
}

 
class ColorPrinter extends Printer{
    public ColorPrinter(String brand) {
        super(brand);
    }
     
    public void print(String content) {
        System.out.println(getBrand()+"彩色打印："+content);
    }
}

 
class BlackPrinter extends Printer{
    public BlackPrinter(String brand) {
        super(brand);
    }
     
    public void print(String content) {
        System.out.println(getBrand()+"黑白打印："+content);
    }
}
 
class Teacher implements IInfo{
    private String name;
    private int age;
     
    public Teacher(String name,int age) {
        this.name = name;
        this.age = age;
    }
     
    public String detail() {
    return "我的名字叫"+name+"，年龄是"+age;
    }
}

接口用implements 继承用extends

4.7 内部类

内部类 嵌套类 局部类 成员类 匿名类 关系如下图。
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象

5异常

异常的体系
Throwable
Error
通常出现重大问题如：运行的类不存在或者内存溢出等。
不编写针对代码对其处理
Exception
在运行时运行出现的一起情况，可以通过try catch finally
Exception和Error的子类名都是以父类名作为后缀

getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream s)
通常用该方法将异常内容保存在日志文件中，以便查阅。

import java.io.FileNotFoundException;
import java.io.FileReader;

public class testYc {
	public static void main(String[] args) {
		try{
			FileReader fr = new FileReader("c:/abc.txt");
					} catch (FileNotFoundException e) {
						//打印输出异常
						e.printStackTrace();
					}		
	
	Mother mother  = new Mother();
	mother.mybaby();
	int [] arr = new int[] {1,2,3};
	System.out.println(arr[2]);
      helloworld test_throw = new  helloworld();  
      test_throw.test();
	}
}
 
class Mother {
 
	private Boy b = null;
 
	// 构造器
	public Mother() {
 
		b = new Boy();
 
	}
 
	public void mybaby() {
		// TODO Auto-generated method stub
		//调用带有异常的方法
		try {
			b.throw_exp();
		}catch(FileNotFoundException e) {
			e.printStackTrace();	
		}	
	}
}
 
class Boy {
	// throws 把异常抛给上层的调用者
	public  void throw_exp()throws FileNotFoundException{
		FileReader fr = new FileReader("c:/1234.txt");
	}
}


class helloworld { /*
     * 
     * throws
     * Exception:如果出现未知错误，会跑出Exception。如果这里加了异常捕捉，调用test方法时，就要加上try...catch
     */ 
        void test() {
       
            String string = "abc";
        if ("abc".equals(string)) {
            throw new NumberFormatException();
        } else {
            System.out.println(string);
           }  
      }
}

以上为 throw throws try catch finally

throw和throws区别
throws用于标识函数暴露出的异常。
throw用于抛出异常对象。
throws与throw的区别：
thorws用在函数上，后面跟异常类名。
throw用在函数内，后面跟异常对象。

6 包和Jar包

被访问的包中的类权限必须是public的。
类中的成员权限：public或者protected
protected是为其他包中的子类提供的一种权限

jar.exe工具对jar的操作。
创建jar包
jar -cvf mypack.jar packa packb
查看jar包
jar -tvf mypack.jar [>定向文件]
解压缩
jar -xvf mypack.jar
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb

7 多线程：

进程与线程的区别：

   1.进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。

   2.线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的。

并行与并发：
并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
线程的生命周期：

sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。

②、sleep方法声明抛出了InterruptedException，所以调用sleep方法的时候要捕获该异常，或者显示声明抛出该异常。而yield方法则没有声明抛出任务异常。

③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法来控制并发线程的执行。

sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。

②、sleep方法声明抛出了InterruptedException，所以调用sleep方法的时候要捕获该异常，或者显示声明抛出该异常。而yield方法则没有声明抛出任务异常。

③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法来控制并发线程的执行。

public class Test1 {  
    public static void main(String[] args) throws InterruptedException {  
       new MyThread("低级", 1).start();  
        new MyThread("中级", 5).start();  
        new MyThread("高级", 10).start();  
    }  
}  
  
class MyThread extends Thread {  
    public MyThread(String name, int pro) {  
        super(name);// 设置线程的名称  
        this.setPriority(pro);// 设置优先级  
    }  
  
    @Override  
    public void run() {  
        for (int i = 0; i < 30; i++) {  
            System.out.println(this.getName() + "线程第" + i + "次执行！");  
            if (i % 5 == 0)  
                Thread.yield();  
        }  
    }  
}

class SomeRunnable implements Runnable
class SomeCallable implements Callable

8 集合 Map与Collection

**

8.1 collection

**
为什么出现集合？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
集合的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
集合框架定义在java.util包中
集合是存储对象的，它也有像数组一样的操作对象的方法，这些方法与DB操作相同，有增，删，查，改等方法

Collection接口有两个子接口：
List（列表） ，Set（集）

List：可存放重复元素，元素存取是有序的。
Set：不可以存放重复元素，元素存取是无序的。

list:
Vector：线程安全，但速度慢，已被 ArrayList替代。
ArrayList：线程不安全，查询速度快。
LinkedList：链表结构，增删速度快。
()
取出LIst集合中元素的方式：
get(int index)：通过脚标获取元素。
iterator()：通过迭代方法获取迭代器对象。

set:
HashSet：线程不安全，存取速度快。
通过equals方法和hashCode方法来保证元素的唯一性。

TreeSet： 线程不安全，可以对Set集合中的 元素进行排序。
通过compareTo或者compare方法中的来保证元素的唯一性。元素是以二叉树的形式存放的。

8.2 map

Map存储的是键值对
Map存储元素使用put方法，Collection使用add方法
Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素
Map集合中键要保证唯一性

9 IO

几种读写方式：
1 inputstream outputstream

2 reader writer类

3 File 类 （非流）4 RandomAccessFile类

java使用Unicode