Xi's LiuY

class Person{ private String name;//私有化成员变量 private int age; static String country="china";//静态代码 Person(String name,int age)//构造函数，对象一建立就调用，可用于对对象初始化 { this.name =name; this.age=age; }

package jihe;class FanX<T>//泛型类{ public void fanx1(T t)//引用泛型类，所以只能根据泛型类的参数传相应类型 { System.out.println(t); } public <Q> void fanx2(Q q)//泛型方法 { System.out.println(q)

package jihe;class Student3{ private String name; private int age; Student3(String name,int age) { this.setName(name); this.setAge(age); } public String getName

package jihe;import java.util.Comparator;import java.util.Iterator;import java.util.TreeSet;class Person7{ private String name; Person7(String name) { this.name=name; } p

package jihe;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;class Mapp{ void mapp() { Map<String,String> m=new HashMap<String,String>()

package jihe;//Map的嵌套import java.util.HashMap;import java.util.Iterator;import java.util.Set;class HM{ void bhm() { HashMap<String,String> yr=new HashMap<String,String>();

package jihe;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;class Person8{ private String name; private int id; Person8(int id,Stri

package jihe;//HashSetDemoimport java.util.HashSet;import java.util.Iterator;class Student{ private String name; private int age; Student(String name,int age) { this.name=na

package jihe;//封装队列和栈数据结构import java.util.LinkedList;class Que{ private LinkedList ll; private int x; Que(int x) { this.x=x; ll=new LinkedList(); } public voi

快速排序原理：通过设定一个关键字将序列分成小于关键字和大于关键字的两部分，在将前后两部分迭代来排序代码（借鉴）：package net.hncu.d0728;/** * 快速排序:指定一个关键字，循环把 * 原理： * @author Administrator * */public class QuickSort { public static void

Java内存划分寄存器 ：属于硬件部分的内容，是cpu做处理的，程序员并不能过多的干涉。栈内存： 存储运行时的方法，局部变量。变量运算区域一结束就会被释放。 局部变量： 方法当中形式参数， 方法内声明的变量，语句当中定义的变量。堆内存 ：存储数组和对象，简单来说堆内存当中存储的都是实体。 实体：能存放多个数据的地方，就称为实体。 只要使用new关键字创建的都存储在堆内存当中。

JAVA原理一、 java的运行机制：JAVA语言需要经过编译生成与平台无关的字节码也就是（.class）文件，在通过JAVA解释器（jvm）来解释执行。二、 JVM：jvm是可运行JAVA字节码文件的虚拟计算机，它具有指令集并使用不同的存储区域，它负责处理指令，管理数据、内存、寄存器。java编译生成的字节码文件是面向JVM的，而JVM正是跨平台的关键，不同平台都有相应的JVM三、开发环

数组概念同一种类型数据的集合。其实数组就是一个容器。Java中数组是用来存固定长度的同类元素的。内存给数组分配的都是连续的空间。数组的声明是一个引用，实现是一个存在对内存的对象数组的声明数组变量的声明：int[] a//首选方法int a[]//来自c语言，不建议使用数组实例的创建a= new int[4];a= new int[]{1,2,3};//注意没有长度a={1,2

函数的定义类当中具有特定功能的独立小程序。 每一个函数都有自己独立的区间就是它所单独存在的地方，需要把函数定义的功能都定义在这个区间当中。函数的特点 语法格式 函数的语法格式： [修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){ 程序代码; return 返回值; }修饰符： 通过关键字对于被修饰的内容赋予的指定的含义。返回值类型：函数通常表现为

package jihe;import java.util.Comparator;import java.util.Iterator;import java.util.TreeSet;//以TreeSetTest2为例将集合泛型，以提高安全性class Stri{ void stri() { TreeSet<String> st=new TreeSet<Stri

package jihe;//Calendar类示例import java.util.Calendar;class DateDemo{ void set() { Calendar c=Calendar.getInstance(); c.set(2020, 1,1);//设置时间 c.add(Calendar.DAY_OF_MONTH, 2);//偏移

package jihe;//将Person类存入集合中，并删除相同元素import java.util.ArrayList;import java.util.Iterator;class Person{ private String name; private int age; Person(String name,int age) { th

/*1.覆盖：当子类出现和父类的函数一模一样时，会调用子类函数.2.子类覆盖父类，必须保证子类子类权限大于等于父类3.静态只能覆盖静态。2.功能扩展：当子类继承了父类，沿袭了父类的功能刀之类中，但是子类虽具备该功能，功能的内容却和父类不一致这时没有必要定义新功能，而是使用覆盖，保留父类功能定义，并重写内容。 final：1. 被final修饰的的类不可以被继承 2.被final

/* 模板方法模式： 在定义功能时，功能的一部分是确定的，而还有一部分是不确定的，这样就把不确定的 部分暴露出去，让该类的子类区完成。 例： 计算一段程序的运行时间（获取时间：System.currentTimeMillis()） */ abstract class GetTime{ public final void getTime()//final是为了防止被子类覆盖（因为c

/* 接口：理解为一个特殊的抽象类（一般用于来扩展实例对象的功能） class定义类，interface定义接口； 接口是多继承，可以被类也可以被接口继承； 接口定义成员都有固定修饰符： 常量：public static final 函数：public abstract 注意： 1.口中成员都是public的； 2. 接口不可以创建对象，因为有抽象方法，需要被子类实现，

/* 异常：就是程序在运行时出现的不正常情况、 异常的由来：问题也就是现实生活中的一个具体事物，也可以通过java的类的形式进行描述。并封装成对象。 其实就是java对不正常情况进行描述后的对象体现。对于问题的划分：比较严重的，java通过Error类进行描述（对于Error一般不编写针对性的代码对其进行处理） 非严重的，java通过Exception得进行描述（对于Excep

包（package）1.对文件进行分类管理2.给类提供多层命名空间3.写在程序的第一行4.类名的全称是 包名.类名5.包是一种封装形式1、包与包之间进行访问，被访问的包中的类以及类中的成员需要public修饰。2、不同包中的子类还可以直接访问父类中被protected权限修饰的成员包与包之间可以使用的权限只有两种，public，protected

/* 死锁（同步中嵌套同步，而使用不同的锁） */class Test implements Runnable{ private boolean flag = true; Test(boolean flag) { this.flag=flag; } public void run() { if(flag) { synchronized(Lock.a)

/*进程： 一个正在执行中的程序（每一个进程执行都有一个执行路径，或者叫一个控制单元）线程：进程中的一个独立的控制单元（线程控制着进程执行，一个进程至少有一个线程）在自定义代码中自定义一个线程1.继承Thread类：步骤： 定义类继承Thread方法 复写Thread类中的run方法(存储要线程运行的代码) 调用线程的start方法（该方法1.启动线程2.调用run方法）

/* 单例设计模式（初始化值） 饿汉式 class Eh { private static final Eh e=new Eh(); private Eh(){} public static Eh getInstance() { return e; } *///懒汉式class Lh{ private static Lh s=null; pri

/* 内部类：定义在累一个类中的类 内部类的访问规则： 1.内部类可以直接访问外部类中的成员，包括私有；格式：外部类.this 2.外部类要访问内部类必须建立对象； 静态内部类： 访问格式： 1.当内部类定义在外部类的成员位置上时，而非私有，可以在外部其他类中， 直接建立内部类对象；格式：内部类名 变量=外部类对象.内部类对象-(Inner Inner2=new Outer.

一1、构造函数：对象一建立就调用，一般用于对对象初始化。2、private：私有化成员变量，该成员被私有化后只能被本类成员方法调用。3、static：static代码，      1、随着累的加载而加载      2、优先于对象存在，      3、被对象所共享      4,、被对象调用，还可以直接被类名调用： 类名.静态成员      注意：

class LpException extends Exception{ LpException(String message) { super(message); }}class SmokeException extends Exception{ SmokeException(String message) { super(message); }}class

package jihe;import java.util.ArrayList;import java.util.Iterator;//去除ArrayList中的重复元素class Arr{ private ArrayList nal =new ArrayList();//建立一个ArrayList集合用来装过滤的集合元素 public ArrayList arr(ArrayLi

反射概念其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。反射的好处：大大的增强了程序的扩展性。反射基本步骤1.获得Class对象，就是获取到指定的名称的字节码文件对象。 2.实例化对象，获得类的属性、方法或构造函数。 3.访问属性、调用方法、调用构