JavaSE学习笔记

1.类的概述

类就是事物的集合和抽象。它所代表的是这类事物所共有的一些行为和属性。

1、《修饰符》不仅可以修饰类，也可以修饰属性和方法。
private:只有在本类中可以看见。只有在本类中才可以去访问和调用。
protected:在本类或者在同一个包中可见。
public：对所有类可见。

默认（无修饰符）：在本类或者同一个包里可见。

    1、方法与主方法：
如果没有返回类型，则必须写有void，不能省略。
如果有返回类型，则定义的方法类型和方法体内的返回值的类型一致。
public string returnString{
    return "返回一个字符串就好了";
}
2、主方法
    它是程序的入口。它有规定的格式，不可以自己定义。
    public static void mian(String[] args){

}

1、构造方法
   作用是用于初始化参数
   所有的数字变量全部设置为0
   所有的boolean类型全部设置为false
   所有的对象变量全部设置为空

**所有类实例化以后的对象都放在堆内存里，包括它的属性和方法。而引用是放在栈内存里。通过引用去访问堆内存里的属性和方法。
2.设计自己的构造方法：
构造方法的名称和类方法的名称必须相同，没有返回类型（没有void，首字母大写）。

3.如果自己写了有参构造方法，那么编辑器不会提供默认的构造方法。如果我们还想要无参数的构造方法，那么需要我们手动实现。

   1.方法的重载
在一个类中可以有多个方法共享同一个名称，只要参数不同就可以。
根据参数的类型和参数数量决定调用哪个方法。
重点***：具有相同的方法名称，不同得参数列表。
    不同得参数列表指得是：参数类型不同，参数的数量不同，参数的

次序不同。

在具有相同的方法名称的情况下，只看参数列表，其它的都不看。

对象的创建和使用

对象是类的实例。对象放在堆内存里，通过关键字new 和构造方法来实例化对象，为对象分配内存空间。而对象的引用是放在栈内存里，没有分配内存空间，只是为了去引用对象，对对象的属性和方法进行操作，就好像引用就是遥控器，而对象就是电视机。

    构造方法的重载

构造方法里面的参数可以相互调用。super（）调用父类的构造器。

对象类型的参数传递
    java中只有值传递。基本类型好理解，直接传递。
        引用类型呢，传递的是引用，而这个引用就是值。
    基本数据类型作为参数，直接操作。

引用类型作为参数，操作的是引用类型指向堆内存中的对象。

Static 关键字
   1、静态变量
    静态变量是属于类的，和对象没有关系。非静态变量是属于某个对象的，每个对象都有该数据的副本。而静态变量只有一个。
            访问静态变量是通过（类名.变量名）来访问的

   2、静态方法
    用static修饰的方法为静态方法。访问静态方法是通过（类名.方法名）来访问的
    （/**一个文件里只允许有一个修饰符为Public的类，而且该类的名称必须和文件名相同**/）

    静态方法不能访问非静态变量（因为静态属性和方法已经加载好了，而非静态的属性和方法还没有被new出来）

    非静态方法可以访问静态变量（静态方法早已加载好了，此时已经手动new出来非静态的方法和属性）


静态属性或方法是在类加载的时候产生的
非静态的属性或方法是在new的时候产生的


   3、静态常量

public static final x =123;

     final关键字

    使用final修饰过的都是不可改变的。

    1、final修饰变量
        恒定不变的属性，可以使用final来进行修饰。变量名建议全部使用大写。final修饰的变量不能改变，如果在程序中重新赋值，编译报错。

    2、final修饰方法
        任何继承类无法覆盖（重写）该方法。但是重载不会受到限制。

    3、final修饰类
        该类不能作为任何类的父类。

类中的方法会全部被自动定义为final类型。

包的介绍

    1、包的介绍
        命名包
        未命名包

---

封装
    1、封装的概述

    2、实现封装

开放的越少，对我们越有利。通过set和get方法进行访问

继承概述
    父类、基类、超类
    子类、派生类

    1、继承的概述
        extends只能继承一个类，java不支持继承多种类

2、子类继承父类之后，子类可以调用父类的属性和方法，也可以重写父类的属性和方法，同时还可以增加自己的属性和方法。

实现继承        
    super（）;
      super()或者 super(有参)放在方法的第一个语句中。

      在调用子类的构造器的时候，如果没有显示的写出super，那么编译器会默认加上super（）无参构造器。

      如果想调用父类的有参的构造器，那么就必须显示调用，编译器不会默认加上的。

创建子类对象的过程就是从底层的基类开始往上，一层层的调用构造方法。

继承关系

Java只支持单继承关系。在写程序的时候要有分层设计的概念，这样方便管理和拓展。

多态
        1、多态
    所谓多态就是一个对象的多种状态。
    在我们这个例子里面：
    Tiger可以看作是Tiger，也可以看作Animal
    Cat可以看作是Cat，也可以看作Animal

Dog可以看作是Dog，也可以看作Animal

抽象类
    1、抽象类的定义
       抽象类是为了子类提供一个规范。
        修饰符 abstract  类名{
            //类体
            修饰符 abstract 返回值类型 方法名（参数类表）；
        /**抽象方法没有方法体 **/
    1、/** 定义一个类，如果这个类是抽象类，那么这个类至少有一个抽象方法**/
        2、/**在抽象类中的方法不一定是抽象方法，但是含有抽象方法的类一定是抽象类 **/
    2、抽象类的使用
       @Override 检测是否重写成功。
     1、  一个类继承了抽象类，就必须要重写该抽象类的所有抽象方法。

2、如果有一个类没有重写抽象类的抽象方法，那么这个类也要定义为抽象类。

接口的概述
    1、接口的概述

    interface 接口的修饰符(定义接口的时候没有class)

    abstract class 抽象类的修饰符
    extends只能是一个
    implements可以是多个

    接口只有抽象方法，比抽象类还要抽象。接口是彻彻底底的抽象。

    接口中只能包含抽象方法和常量，不能够有变量、初始化块、构造器。

    注意事项：
         1、接口的修饰符只有两种：默认和public.
         2、接口内的变量会被设置成共有的，静态的和最终的字段。

3、接口是抽象方法和常量的属性集合。

接口的实现

 实现方式：class 类名 implements 接口1,接口2,接口3{
    方法1（）{
    }
    方法2（）{
    }
    ......
}
接口实现的注意事项：
    1、为接口中所有的方法提供具体的实现
    2、必须遵守重写的所有规则：
                    1、子类的重写方法不能抛出更大的异常
                2、子类的重写方法不能有更小的访问范围

    3、保持相同的返回类型。

多继承也就是继承多个接口
    1、这些接口之间需要使用逗号来分隔开。

2、如果这几个接口都有相同的方法和相同的变量，那 么相同的变量是可以通过 （接口名.变量名） 的形式来访问。相同的方法将被其中的一个接口使用。相同的方法只重写一个就可以了，不用管是哪个接口的方法。

接口的应用
    1、方法的修饰符
    接口中变量的修饰符：public static final
    接口中方法的修饰符：public abstract 

    2、接口类型引用变量

（重点）

成员内部类
   1、内部类的概述
    一个类被嵌套定义在另一个类中，那么这个类就被称为内部类。包含内部类的类就被称为外部类。
    内部类相当于外部类的成员变量或者是方法。

    如何构造内部类
        Outer out = new Outer();
        Outer.Inner in = out.new Inner();

in.print();

匿名内部类

    通过内部匿名类也就是父类的子类去继承父类的方法，然后去重写方法，实现调用。
public class TestInner {
public static void main(String[] args) {
    InterfaceI i =new InterfaceI() {

        @Override
        public void ShowMe() {
            System.out.println("这是匿名内部类的ShowMe方法");
        }
    };
    i.ShowMe();
    Pa  pa=new Pa(){
        public void eat(){
            System.out.println("子类在吃东西");
        }
    };
    pa.eat();
}

}
interface InterfaceI{

public void ShowMe();

}
class Pa{
public void eat(){
System.out.println(“父类在吃东西”);
}

}

1、局部内部类
    在类的局部位置进行定义的类叫做局部内部类。（在方法内定义的类叫做局部内部类）
    在局部内部类中去访问方法当中的局部变量时，该局部变量必须定义成是final类型的。但是访问外部类中的成员变量是可以随便访问的。 
    为什么局部变量是final类型的？

因为方法当中的局部变量是随着方法的执行完毕后，局部变量也随即被释放掉内存，也就死掉了。但是局部内部类的生命周期不会立即死掉，所以需要访问的局部变量必须是恒定不变的，不能修改的final类型。

静态内部类
    1、在内部类前添加static修饰符。 
    2、静态内部类中可以声明static成员变量，非静态内部类中不可以。
    3、静态内部类不可以使用外部类的非静态成员变量。
    4、创建静态内部类的对象，不需要其外部类的对象。

    //创建非静态内部类的形式
    Outer o = new Outer();
    Outer.Inner i =o.new Inner();

    //创建静态内部类的形式

Outer.Inner i = new Outer.Inner();

引用外部类的对象
    1、引用外部类的对象
        Inner:this.count
        Quter:Quter.this.count

    2、内部类的继承
    public class Test extends A.B{
        public  Test(A a){
        a.super();
        }
    } 
    class A{

        class B{

        }
    }       

想要继承一个内部类，必须要通过构造器对内部类中的外部类进行实例化。
public Test(A a){
a.super();

}

异常概述
 1、什么是异常
    就是程序运行过程中出现的不正常的现象。
    try:把可能发生异常的代码包起来，发生异常时，将异常抛出
    catch:捕获异常并处理
    finally:不管是否法伤异常，都会执行
    throw:手动引发一个异常
    thorows:定义任何被调用方法的异常。
 2、异常出现的原因
    用户输入错误
    代码的错误
    环境因素

异常机制保证了程序的健壮性！

异常的分类
     Throwable
     Error      Exception
        Error:它是Java运行时的内部错误以及资源耗尽错误。很难恢复，不期望用户来处理。
     Exception:
     RuntiemException:运行时异常。(类转换，空指针，数组越界等的异常)

非 RuntiemException:由环境因素导致。

获取异常信息

程序发生异常的时候，程序就直接从try执行到catch语句块，不再继续往下执行。如果try中的代码块没报错，则不会执行catch。

异常声明
    :指一个方法不处理它所产生的异常    ，而是调用层次向上传递，谁调用的这个方法，谁来处理。
    public class Test {

public static void main(String[] args) {
    Test test = new Test();
    System.out.println("main方法开始执行");
    try {
        test.Test1();
    } catch (ArithmeticException e) {
        System.out.println(e.getMessage());
    }
    System.out.println("main方法执行完毕");
}

public void Test1()throws ArithmeticException{
    System.out.println("Test1开始执行");
    System.out.println(1/0);
    System.out.println("Test1执行完毕");
}
public void Test2(){
    Test1();
}

}

---

手动抛出异常 
  throw exception; 参数exception表示要抛出的异常对象，该对象是     throwable类的子类，而且只能是一个。
  try catch finally是可以嵌套使用的。

    public class TrycatchfinallyTest {
    public static void main(String[] args) {
        double a = Math.random();


        try {
                if(a>0.5){
                System.out.println(a+"不报错");
                }else{
                    throw new Exception();
                }

        } catch (Exception e) {
            System.out.println("这是外层捕获对象"+e);
            try {
                System.out.println(1/0);
            } catch (ArithmeticException e1) {
                System.out.println("这是内层捕获的对象"+e1);
            }finally{
                System.out.println("这是内层的finally块");
            }
        }finally{
            System.out.println("这是外层finally块");
        }
    }

}

异常链：
    两个或者多个不同得异常出现在同一个程序中，并且会发生嵌套抛出，我们称之为异常链。

        public class ExceptionChainTest {
public static void main(String[] args)  {
    Calculator c =new Calculator();

    try {
        c.chufa(4.5,0);
    } catch (NumberCalculateException e) {
        e.printStackTrace();
        System.out.println("错误原因");
    }

}

}

class Calculator{
public double chufa(Double a,double b) throws NumberCalculateException{
if(b==0){
NumberCalculateException e =
new NumberCalculateException(“计算错误”);
NegtiveNumberException e1 =
new NegtiveNumberException(“除数不能为0”);
e.initCause(e1);
throw e;
}
return 0;
}
}
class NegtiveNumberException extends Exception{
public NegtiveNumberException(String msg){

    super(msg);
}

}
class NumberCalculateException extends Exception{
public NumberCalculateException(String msg){
super(msg);
}

}

定义自己的异常类

1、创建自己的异常类

1、继承Throwable
2、继承Exception
修饰符 class 类名 extends Exception{
    //类体
}

2、使用自己的异常类
第一自己的异常，一般用于throw
public class AgeTese {
public static void main(String[] args) {
try {
AgeTese.AgeLeval(1000);
} catch (IllegalAgeException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static String AgeLeval(int age) throws IllegalAgeException{
if(age>=10 && age<=18){
return “少年”;
}else if (age>18 && age<=30) {
return “青年”;
}else if (age>30 && age<=60) {
return “中年”;
}else if (age>60 && age<=120) {
return “老年”;
}else{
//抛出自己定义的异常
throw new IllegalAgeException(“非法的年龄!!!!!!”);
}
}

}

/**
* 定义自己的异常类
* @author Administrator
*
*/
class IllegalAgeException extends Exception{
public IllegalAgeException(String msg){
super(msg);
}

}

更正异常的一个知识点

try 不能单独出现，后面必须跟着catch 或者finally 或者两者都有。
例如：try{ 或者 try{
}catch{

                 }finally{
                   }
}catch{
}

或者 try{

}finally{

}

线程与进程
1、线程与进程
进程：执行中的程序。
线程：轻量级的进程。
线程本身不能单独运行，必须放在一个进程中才能执行。
2、Java的线程模型
1、新建状态
线程被创建之后便处于新建状态
2、就绪状态
新建状态的线程调用start（）进入就绪状态
阻塞状态的线程解除之后进入就绪状态
3、运行状态
处于就绪状态的线程获得了CPU的资源，该线程就进入运行状态。

4、阻塞状态
    是一个正在运行的线程，因为一些原因让出了CPU资源（获得时间片）暂时中止而进入的状态。
5、终止状态
    1、正常终止
    2、强制终止：stop / destroy 
    3、异常终止：当线程执行过程中产生了异常，线程就会终止。

---

创建线程的第一种方式
    1、继承Thread类创建线程

    class 类名 extends Thread{
        public void run(){
            //相关代码
            }

}

实现Runnable接口

1、实现Runnable接口
class 类名 implements Runnable{
public void run(){

    }
}
A a=new A();
Thread t =new Thread(A);
Thread t1=new Thread(A,"线程1")

2、两种方法的比较
extends Thread 单继承

implements Runnable 多实现 使用的时候非常灵活

多线程应用

1、多线程并发执行
Java对于线程启动后唯一能保证的是每个线程都被启动并且结束。但是对于哪个先执行，哪个后执行，什么时候执行，是没有保证的。

2、线程优先级
Java中优先级高的线程有更大的可能获得CPU，但不是优先级高的总是先执行，也不是优先级低的线程总是后执行。

---

线程调度的三个方法

1、休眠方法sleep(毫秒数) sleep(毫秒数,纳秒数)

2、暂停方法yield() a.yield() 指的是a释放资源后，让其他的线程来争夺。也有 可能a又夺得资源。

3、挂起方法join() a.join()

---

线程同步问题

多个线程共享一个资源没有进行控制。

//package com.practices.day58;

同步问题Java的解决方案

1、同步问题的Java的解决方案
同步方法：当线程进入同步方法的时候，会获得同步方法所属对象的锁，一旦获得对象锁，则其他线程不能再执行被锁对象的其他任何同步方法。只有在同步方法执行完毕之后释放了锁，其他线程才能执行。
//package com.practices.day59

    synchronized 方法声明{

    }


同步块：

    synchronzized(资源对象){
        //需要进行同步的方法 
    }

---

死锁问题

1、死锁问题

线程A现在占有资源2，需要请求资源1

线程B现在占有资源1，需要请求资源2

生产者和消费者模型：
    涉及到线程同步，两者之间的实时通信。
    源码：package com.practices.day62;