u011493348的博客

class Halfsort{ public static void main(String[] args) { int[] arr = {1,2,4,5,7,9}; int index=getIndex(arr,8);//在数组中插入数字8 System.out.println("index="+index); } /* 折半插入一个数，前提是数组是有序的。 *

/* this: 1、用于区分同名变量（成员变量和局部变量） 2、用于构造函数间的调用（构选函数间调用只能用this） 3、只能是构选函数里面的第一个语句，因为初始化要先执行。 比较两个人的年龄是否相同。*/class Person{ private int age; Person(int age) { this.age=age; } public bo

//该文件要结合ArrayTool.class类使用。class ArrayToolDemo { public static void main(String[] args) { int[] arr={2,1,5,9,6,8}; int max=ArrayTool.getMax(arr);//不能建立ArrayTool类的对象，因为该类的构的函数已经私有化了，所以只能用(类名.方

/**这是一个可以对数组进行操作的工具类，该类中提供了获取最大值、最小值，排序等功能静态的应用。每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。但发现了问题：1、对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。2、操作数组的 每一个方法都没有用到Array

class Exception{ void getMessage();}class AException extends Exception{}class ExceptionDemo { public static void main(String[] args) { System.out.println("Hello World!"); }}

/*题目：存入一个人的姓名和性别后，输出这个人的姓名和性别。再存入再输出。 要求用多线程来操作，其实就是三个线程：一个主线程，再创建两个线程（输入一个线程、输出一个线程）1，同步代码 synchronized 确保其安全性。 synchronized(this){} synchronized(Input.class){} 多个代码块用同一个锁:Input.class线

/*join:当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。join可以用来临时加入线程执行。*/class Demo implements Runnable{ public void run() { for(int x=0; x<70; x++) { System.out.println(Thread.currentTh

/*有三个for循环，让三个循环开三个线程同时运行。其中一个main线程，再创建两个线程。*/class ThreadTest { public static void main(String[] args) { new Thread()//匿名内部类 { public void run() { for(int x=0; x<100; x++)

class Person{ private int age; private String name; /* 构造代码块。 作用：给对象进行初始化。 对象一建立就运行，而且优于构造函数执行。 和构造函数有什么区别呢？ 构造代码块是给所有对象进行统一初始化， 而构造函数是给对应的对象初始化。 构造代码块中定义的是不同对象共性的初始化内容。 */ { Syst

/*对象一建立就会调用与之对应的构造函数。构造函数的作用：可以用于给对象进行初始化。构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数没有了。构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加具备的功

/*private:私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数）私有只在本类中有效。注意:私有仅仅是封装的一种体现形式。*///以下为封装实例class Person{ private int age; public void setAge(int a) { if(a>0&&a<120) { age=a; speak(); }

/*this 看上去，是用于区分局部变量和成员变量同名的情况。this：就代表本类的对象，到底是哪一个呢？ this代表它所在的函数所属对象的引用。 简单来说，哪个对象在调用this所在的函数，this就代表哪个对象。*/class Person{ private String name; private int age; Person(String name)

/*this语句：只能用于构造函数间的相互调用。this语句只能定义在构造函数的第一行，因为初始化要先执行。*/class Person{ private String name; private int age; Person() {} Person(String name) { this.name=name; } Person(String name,in

/*需求：给人定义一个比较年龄是否相同的功能。*/class Person{ private int age; Person(int age) { this.age=age; } public boolean compare(Person p) { return this.age==p.age; }}class ThisTest { public sta

class Person{ private String name="haha"; private int age; Person(String name, int age) { this.name=name; this.age=age; } { System.out.println("Gouzaodaimakuai..."+name); } static {

/*懒汉式：1、对象是方法被调用时，才初始化，也可做延时加载。2、SingleLanhan类进内存，对象还没有存在，只有在调用了getInstance方法时，才建立对象。开发多用饿汉式*//*单例设计模式：饿汉式*/class SingleEhan{ private static SingleEhan s = new SingleEhan(); private Sin

/*设计模式：解决某一类问题最行之有效的方法。java中有23种设计模式。单例设计模式：解决一个类在内存中只有一个对象。想要保证对象唯一性。1、为了避免其它程序过多建立对象，先禁止其它程序建立该类对象。2、还为了让其它程序可以访问该类对象，只好在本类中，自定义一个对象。3、为了方便其它程序对自定义对象的访问，可以对外提供一些访问方式。这三部怎么用代码实现呢》？1、将构造函数私

/*单例设计模式之饿汉式实例。*/class Student { private int age; public void setAge(int age) { this.age=age; } public int getAge() { return age; } private Student(){} private static Student s=new

/*静态代码块。格式：static{ 静态代码块中的执行语句;}特点：随着类的加载而执行，只执行一次。并优先于主函数，也优先于构造代码块。用于给类进行初始化的。而构造代码块是给对应对象进行初始化的，并且是一个对象进来一下就执行一次，有多个对象进来初始化就执行多次。*/class StaticCode{ StaticCode() { System.out.prin

/*静态：static用法:是一个修饰符，用于修饰成员（成员变量，成员函数）,不能修饰局部变量。static特点：1、随着类的加载而加载。 也就是说：静态会随着类的消失而消失。说明它是生命周期最长。2、优先于对象存在 明确一点：静态是先存在的，对象是后存在的。3、被所有对象共享。4、可以直接被 类名所调用 。实例变量和类变量（静态变量）的区别：1、存放位置。

/*当多个类中出现相同功能，但是功能主体不同这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。抽象：看不懂。抽像类的特点：1、抽象方法一定在抽象类中。2、抽象方法和抽象类都必须被abstract关键字修饰。3、抽象类不可用new创建对象，因为调用抽象方法没有意义。4、抽象类中的抽象方法要被使用，必须由子类重写其父类中所有的抽象方法后，才能建立子类对象调用 如果子

/*假如我们在开发一个系统时需要对员工进行建模，员式包括3个属性。姓名、工号、工资。经理也是员工，除了有员工的属性外，还有奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性的访问。分析：打工人:公司雇佣的打工人员工类：name id pay经理类：继承了员工，并有了自自己特有的bonus并且员工和经理都是被公司雇佣的打工人*/abstract

class Demo{ //static int x=3; public static void main(String[] args) { //x=5; //System.out.println(x); //new Person(); new Gouzao(); }}class Gouzao{ private Gouzao() { System.

/*说到继承extends，那么子父类中的三大特点：1、子父类中变量的特点。2、子父类中函数的特点。3、子父类中构造函数的特点。重写：子父类中函数的特点之一为重写。重写要注意：1、子类权限>=父类权限。才可以被重写。 但是如果父类权限为private,子类就根本不知道父类有这个功能，也就不存在重写了。2、静态只能重写静态。重载和重写的区别：重载：只看同名函数的

/*说到继承extends，那么子父类中的三大特点：1、子父类中变量的特点。2、子父类中函数的特点。3、子父类中构造函数的特点。子类的实例化过程。结论：子类的所有构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super()语句。当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造

/*final关键字，作为一个修饰符，可以修饰 类、函数、变量。1、被final修饰的类不以可被继承。2、被final修饰的方法不可以被重写。但是子类可以继承父类中被final修饰的方法。3、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量， 当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起了名字，方便阅读。 而这个

/* 接口：初期理解，可以认为是一个特殊的抽象类。 当抽象类中的方法都是抽象的，那么该类可以通过接口的形式表示。class用于定义类interface用于定义接口接口定义时，格式特点：1、接口中常见定义：常量、抽象方法。2、接口中的成员都有固定修饰符 常量：public static final 方法：public abstract注意：接口中的成员都是publ

/*基类，都是运动员两个足球倶乐部的人当然也是运动员运动员当然都有play()方法，只不过实现的方法不一样而吸烟则是可有可无的功能，不是运动员必须具有的功能，所以吸烟就是扩展功能，用implements去让有该功能的类去实现。以上描述简单来说，就是父类必须有的功能，就定义成class类，子类去继承，因为子类是该class体系中的一员； 子类也可以有自己扩展的功能，该

/*需求：获取一段程序运行的时间。原理：获取程序开始和结束的时间并相减即可。获取时间：System.currentTimeMillis();此程序提炼出一种《模板方法设计模式》什么是模板方法呢？在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去实现。*/abstract class

/*Object类是java中所有类的父类，传说中的上帝Object类中有 equals(Object obj) 方法，所以所有类都可以拿来用多态中，子类想要访问子类特有数据时，就得向下转型。*/class Demo{ private int num; Demo(int num) { this.num=num; } public boolean equals(Obj

/*在多态中，成员函数的特点：1、在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过；如果没有，编译失败。2、在运行期间：参阅对象所属的类中是否有调用 的方法。简单总结就是：成员函数在多态调用 时，编译看左边，运行看右边。开发不多见，面试经常考：1、在多态中，成员变量的特点： 无论编译和运行，都参考左边（引用型变量所属的类）2、在多态中，静态成员函数的特点：

/*电脑运行基于主板。主板上插上网卡、声卡(假如有主板时，声卡还没有开发出来)主板按照PCI规则来生产槽后期科技发明出来的，可扩展到主板上的东西，也按照PCI规则来生产。*///--------接口 多态的应用----------------interface PCI{ public abstract void open(); public abstract void c

/*多态：可以理解为事物存在的多种体现形态。人：男人，女人动物：猫，狗猫 x = new 猫;动物 x = new 猫;1、多态的体现 父类的引用指向自己子类的对象。 父类的引用也可以接收自己的子类对象。2、多态的前提 必须是类与类之间有关系，要么继承，要么实现。 通常还一个前提：存在重写。3、多态的好处 多态的出现大大的提高程序的扩展性。4、多态的弊端

/*基础班学生： 学习(不确定)，睡觉(坐着睡)。高级班学生： 学习(不确定)，睡觉(躺着睡)。冲刺班学生: 学习(不确定)，睡觉(躺着睡)。可以将这三类事物进行抽取。分析：1、都学习，但学习内容不确定，就在父类中定义成抽象的。2、都睡觉，睡觉多数（2：1）是躺着睡，那么在父类中的函数就定义出函数主体，内容为躺着睡，子类直接去继承， 少数要坐着睡，那就让它去重写成坐着睡

/*多态--转型Animal a = new Cat(); //向上转型a.eat();如果想要调用猫的特有方法，如何操作？强制将父类的引用，转成子类类型。也叫做向下转型。如下：Cat c = (Cat)a; //向下强转c.catmouse();千万不要出现这样的操作：将父类对象转成子类类型。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以

/*dao: date access objectcrud: creat read update delete对数据进行操作： JDBC Hibernate1、连接数据库2、操作数据3、关闭数据库*//*该程序背景：前期用的JDBC方法访问数据库，后来出了新的方法，比JDBC好，所以要求用Hibernate来访问数据库，考虑到两个都只有add() delete()方法，

/*匿名内部类：1、匿名内部类其实就是内部类的简写格式。2、定义匿名内部类的前提” 内部类必须是继承一个类或者实现接口3、匿名内部类的格式 ： new 父类或者接口(){定义子类内容}4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。5、匿名内部类中定义的方法最多不要超过3个。*/abstract class AbsDemo{ abstra

/*有一个圆形和一个长方形。都可以获取面积对于面积如果出现非法数值，视为是获取面积出现问题。问题通过异常来表示。*/class NovalueException extends RuntimeException{ NovalueException(String message) { super(message); }}interface Area{ publi

class Demo { public static void func() { try { throw new Exception(); System.out.println("a"); } catch (Exception e) { System.out.println("b"); } } public static void main

/*在函数上声明异常便于提高安全性，让调用处进行处理，不处理编译失败。throws关键字。抛出异常。*/class Demo{ int div(int x, int y) throws Exception//在功能上通过throws关键字声明了该功能有可能出现问题 { return x/y; }}class ExceptionDemo2 { public stat