JasonZi的博客

注意：基本类型数值可以通过比较运算比较大小和相等。>             对象也可以比较是否相等，谁大谁小。都是通过方法完成。           对象比较相同：Object equals(Object obj):子类一般情况下都会复写，建立自己判断相同的依据。           对象比大小用的也是方法，该功能有三种情况。所以使用int类型。正数，负数，零          

/* * 构造函数间调用。 * 1.构造函数只能被构造函数调用，不能被一般方法调用。 * 2.构造函数间，通过this关键字 * 3.this代表的是对象，哪个对象调用this所在的函数，this就代表哪个对象。 *   this带上参数列表的方式就是可以访问本类中向对应的构造函数 *   比如：this("list")：访问的就是本类中，带有一个字符串参数的构造函数。

/* * 内部类： *   其实将类定义到了另一个类的内部。 *   A类要直接访问B类中的成员时，可以将A类定义到B类中，作为B类的内部类存在。 *  * 访问规则： *   内部类可以直接访问外部类中的成员。 *   外部类想要访问内部类，只能创建内部类的对象来访问。 *  * 非静态内部类中不可以定义静态方法。 * 静态内部类只能访问外部类中的静态成员

/*throw和throws有什么区别呢？1.位置不同。throws用在函数上，后面跟的是异常类，可以跟多个。throw用在函数内，后面跟的是异常对象。2.功能不同throws用来声明异常，让调用者只知道该功能有可能出现的问题，并有调用者可以给出预先的处理方式。throw抛出具体问题对象，执行到throw功能就已经结束了，跳转到调用者，并将具体的问题对象也抛给调用者。

/* * 练习一： * 1.建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并得出两个图形的面积。 * 注：体现面向对象特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。*/class NoValueException extends RuntimeException{ NoValueException() {

/* * 多线程的运行根据cpu的切换完成的。怎么切换cpu说了算 * 所以多线程运行有一个随机性（cpu的快速切换造成的）。 *  * jvm中的多线程。 * 至少有两个线程：一个是负责自定义代码运行的。这个从main方法开始执行的线程称之为主线程。 *             一个是负责垃圾回收的。 *              *通过实验，会发现每次结果都不一

public class StringDemo1 { public static void main(String[] args) {  /*   * String演示   * 1.常量：一旦初始化就不会被改变   *    */  String str="abcd";  //字符串本身 就是一个对象  //当虚拟机启动的时候，字符串就已经开始存储了，存储在了方法区

package cn.jason.stringbuffer.demo;public class StringBufferDemo { public static void main(String[] args) {  /*   * stringbuffer:字符串缓冲区 作为一个字符容器 特点：   *  1.长度可以变化    *  2.可以对内容通过指定方法进行修改

package cn.jason.wrapper.demo;public class WrapperDemo { public static void main(String[] args) {  /*   * 基本数据类型对象包装类的重要功能：在基本类型和String类型之间互相转换   *    */  /*字符串转成基本数据类型  使用的是    parse基

集合就是存储对象最常用的一种方式数组和集合同是容器，有何不同？ 数组存储基本数据类型，也可以存对象（什么都能存储），数组长度是固定的。 集合只能存储对象，集合长度是可变的。集合类的特点： 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。 因为容器中数据结构不同。容器有很多种，不断地共性功能抽取，形成了集合体系-->集合框架顶层就称之为Collect

package cn.jason.test;import java.util.Comparator;import java.util.Set;import java.util.TreeSet;public class Test { public static void main(String[] args) {  sortStringByLength(); } pu

package cn.jason.list.test;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class ArrayListTest2 { public static void main(String[] args) {  /*   * 练习2：定

package cn.jason.foreach;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class ForeachDemo { public static void main(String[] args) {  /*   * JDK1

package cn.jason.test;import java.util.Iterator;import java.util.Map;import java.util.Set;import java.util.TreeMap;public class Test { public static void main(String[] args) {  /*   *

package cn.jason.test;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import org.junit.After;import org.junit.Before;

自动线程数固定线程数

public class Demo21_3 { public static void main(String[] args) {  /*   * 3.补足compare函数内的代码，不许添加其他函数   */  Circle21[] cir = new Circle21[4];//  Circle21 cir[] = new Circle21[4];        相同

/* 多态：多种形态    重点说的是对象的多态性。 class 动物{} class 狗   extends 动物{} 狗  x = new 狗(); 动物  x = new 狗(); 狗对象(实例)即使狗类型，又是动物类型。多态性  多态在程序中的体现：父类的引用或者接口的引用指向了子类的对象。  ! 多态的好处：提高了代码的拓展性 

/*抽象类与接口的区别*///犬类，缉毒类，缉毒犬类/*abstract class 犬{ abstract void 吃(); abstract void 叫();}interface 犬{ abstract void 吃(); abstract void 叫();}class 缉毒犬  extends 犬{ void 吃(); voi

/* 当抽象类中所有的方法都是抽象的。 这时，可以把抽象类用另一种形式来表示，接口。  初期可以理解为接口是特殊的抽象类。 *///定义接口//interface Inter//{// public static final int NUM=4;          //全局常量// public abstract void show1();         

JAVA 常用快捷键总结         ctrl+1              智能选择alt+/          智能补充shift+enter       跳到下一行应该在的行首ctrl+i          直接让光标到指定的位置上ctrl+shift+o      全部导包ctrl+shift+f      直接对代码进行标准格式化Alt+↓      

public class StringBufferDemo3 {          public static void main(String[] args) {                   StringBuffer buf1 = new StringBuffer("hello");                   StringBuffer buf2 = new St

JRE:  运行环境：jvm(虚拟机)+类库JDK:  开发工具包：开发工具+JREJDK里包含了jre。使用JDK开发完成的java程序，交给JRE运行java类，开头要大写，多个单词组合开头要大写。五大内存区：栈，堆，方法区，寄存器，本地方法区（native方法）一共有两个关键字修饰完的方法是没有方法体的，1：abstract  2：native本地方法区里面全都是na

package cn.jason.reflect;import cn.jason.domain.Person;public class ReflectDemo {         public static void main(String[] args) throws ClassNotFoundException {           /*                 

IO流： IO：用于处理设备上的数据的技术。设备：内存，硬盘，光盘 流： 系统资源，windows系统本身就可以操作设备。各种语言只是使用系统平台上的这个资源。  并对外提供了各种语言自己的操作功能，这些功能最终调用的是系统资源。  使用完资源一定要记住：释放。   IO：java中所涉及的功能对象对存储在java.io包中设备上数据最常见的存储表现形式文件file   F...

package cn.jason.test;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.util.Pr

package cn.jason.test;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamR

package cn.jason.test;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;impor

网络编程UDP(面向无连接，不可靠，速度快)---发送端，接收端。DatagramSocket --- DatagramPacket(数据包)TCP的传输：上传。问题：两端等待的情况。说明有阻塞式方法。没有读取到结束标记。shutdownweb原理：并发访问。 server端：将来访的客户端都封装到了一个单独线程中。  SereverSocket server = new Serv

客户端：package cn.jason.net.tcp.test1;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWrit

/* * 面向对象：继承，封装，多态。 * 封装：隐藏实现细节，对外提供公共的访问方式（接口） * 封装的体现之一：将属性都私有化（private），对外提供setXXX,getXXX方法来访问。 * 好处1：提高安全性，不允许直接访问细节，并通过公共的方式来访问，可以实现可控 *   2.提高了易用性。     3.提高了复用性。     4.隔离了变化。 */ 

/* * 静态static函数中的使用。 * 什么时候函数需要静态修饰？ * 该函数没有访问过对象中的属性时，就需要静态修饰。 *  *  * static 是什么？ * 成员修饰符 * 特点： * 1.被静态修饰的成员，可以直接被类名所调用 * 2.静态成员优先于对象存在。 * 3.静态成员随着类的加载而加载，随着类的消失而消失，静态成员生命周期很长。

/*单例设计模式：本类中只创建一个对象，外部通过方法只调用，改变，这一个对象*/class Single{              //饿汉式 //创建一个本类对象 private static Single s = new Single(); //构造函数私有化，外界不可访问，不可创建对象 private Single(){} //定义一个方法返回该对象，让其程

！   继承的细节：对于父类中的私有部分，子类对象是无法直接访问的。    private:是一个“权限修饰符”。        class Person{       private int age;       为了安全性，不被外界使用，降低访问权限。   和封装（set,get）同种思想。    }    new Person().age;            虽然

/*final关键字：最终。1.final修饰符，可以修饰类，修饰方法，修饰变量（包括局部变量）  2.final修饰的类不可以被继承。3.final修饰的方法不可以被覆盖。4.final修饰的变量，是一个常量，只能赋值一次。（固定死了，不可再改变）      当使用的数据不变时，需要定义阅读性强的名称来表示该数据，并将该数据final化；      被final修饰的

/*  描述一个事物，却没有足够的信息，这时就将这个事物称为抽象事物。      面对抽象的事物，虽然不具体，但是可以简单化。   不用面对具体的事物。      特点：   1.抽象方法一定定义在抽象类中，都需要用abstract来修饰。   2.抽象类不能实例化，不能用关键字new关键字创建对象。   3.只有子类覆盖所有的抽象方法后，子类具体化，子类就可以