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、继承Throwable2、继承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;