独狼的博客

原创 Java基础之多线程的概述、好处以及弊端

/*进程：正在进行中的程序(直译). 线程：就是进程中一个负责程序执行的控制单元(执行路径)一个进程中可以多执行路径，称之为多线程。一个进程中至少要有一个线程。开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。多线程好处：解决了多部分同时运行的问题。多线程的弊端：线程太多回到效率的降低。其实应用程序的执行都是cpu在做着快速的切换完成的。这个切换是随机的。JVM启动时就启动了多个线程，至少有两个线程可以分析的出来。

原创 Java基础之包的概述以及导入

PackageDemo:package mypack;//import packa.DemoA;//导入了packa包中的DemoA类。//import packa.DemoAA;//import packa.DemoAAA;/*import packa.*;//导入了packa包中所有的类。import packa.abc.*;packa\DemoA.class packa\abc\DemoAbc.class*///导包的原则：用到哪个类，就导入哪个类。//import 干

原创 Java基础之Object类的equals方法、hashCode方法、getClass方法和toString方法

/*Object:所有类的根类。Object是不断抽取而来，具备着所有对象都具备的共性内容。常用的共性功能：*//*class Fu // extends Object{ Fu() { super(); }}class Zi extends Fu{ Zi() { super(); }}*/class Person extends Object{ private int age; Person(int age) { this.age

原创 Java基础之异常的注意事项

异常的注意事项：1，子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。2，如果父类抛出多个异常，那么子类只能抛出父类异常的子集。简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。 注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try .interface Inter{ void function();}class D implements Inter{ public void functi..

原创 Java基础之异常的应用

/*毕老师用电脑上课。问题领域中涉及两个对象。毕老师，电脑。分析其中的问题。比如电脑蓝屏啦。冒烟啦。*/class LanPingException extends Exception{ LanPingException(String msg) { super(msg); }}class MaoYanException extends Exception{ MaoYanException(String msg) { super(msg); }}..

原创 Java基础之finally代码块

class Demo{ public int show(int index)throws ArrayIndexOutOfBoundsException { if(index<0) throw new ArrayIndexOutOfBoundsException("越界啦！！"); int[] arr = new int[3]; return arr[index]; }}class ExceptionDemo5 { public static void mai..

原创 Java基础之trycatch的使用

/*异常处理的捕捉形式：这是可以对异常进行针对性处理的方式。具体格式是：try{ //需要被检测异常的代码。}catch(异常类 变量)//该变量用于接收发生的异常对象{ //处理异常的代码。}finally{ //一定会被执行的代码。}异常处理的原则：1，函数内容如果抛出需要检测的异常，那么函数上必须要声明。 否则必须在函数内用trycatch捕捉，否则编译失败。 2，如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。

原创 Java基础之自定义异常，编译异常和运行异常的区别

/*对于角标是整数不存在，可以用角标越界表示，对于负数为角标的情况，准备用负数角标异常来表示。负数角标这种异常在java中并没有定义过。那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述。并封装成对象。这种自定义的问题描述成为自定义异常。 注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类才有资格具备可抛性。 才可以被两个关键字所操作，throws throw异常的分类：1，编译时被检测异常:只要是Exception和其子类都是，除了

原创 Java基础之异常的抛出过程

/**/class Demo{ public int method(int[] arr,int index) { if(arr==null) throw new NullPointerException("数组的引用不能为空！"); if(index>=arr.length) { throw new ArrayIndexOutOfBoundsException("数组的角标越界啦，哥们，你是不是疯了？："+index); } if(index&lt.

原创 Java基础之异常的概述和体系

/*异常：是在运行时期发生的不正常情况。。在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类，就称为异常类。 以前正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离。提高阅读性.其实异常就是java通过面向对象的思想将问题封装成了对象.用异常类对其进行描述。不同的问题用不同的类进行具体的描述。 比如角标越界。空指针等等。问题很多，意味着描述的类也很多，将其共性进行向上抽取，形成了异常体系。最终问题（不正常情况）就分成了两.

原创 Java基础之对象的初始化过程

原创 Java基础之匿名内部类的一个小细节

class Outer{ void method() { Object obj = new Object() { public void show() { System.out.println("show run"); } }; obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型。 //这样就不能在使用子类特有的方法了。 }}class InnerClassDemo6 { public stat...

原创 Java基础之匿名内部类的应用

interface Inter{ void show1(); void show2();}class Outer{ /* class Inner implements Inter { public void show1() { } public void show2() { } } */ public void method() {// Inner in = new Inner();// in.show1();// in.show2(.

原创 Java基础之匿名内部类概述

/*匿名内部类。就是内部类的简写格式。 必须有前提： 内部类必须继承或者实现一个外部类或者接口。匿名内部类：其实就是一个匿名子类对象。 格式：new 父类or接口(){子类内容}*/abstract class Demo{ abstract void show();}class Outer{ int num = 4; /* class Inner extends Demo { void show() { System.out.println("s.

原创 Java基础之局部内部类

/*内部类可以存放在局部位置上。 内部类在局部位置上只能访问局部中被final修饰的局部变量。*/class Outer{ int num = 3; Object method() { final int x = 9; class Inner { public String toString() { return "show ..."+x; } } Object in = new Inner(); return in;//0x004

原创 Java基础之内部类的一个小细节

/*为什么内部类能直接访问外部类中成员呢？那是因为内部类持有了外部类的引用。 外部类名.this*/class Outer{ int num = 3; class Inner { int num = 4; void show() { int num = 5; System.out.println(Outer.this.num); } } void method() { new Inner().show(); }}class Inne...

原创 Java基础之内部类概述

/*内部类访问特点：1，内部类可以直接访问外部类中的成员。2，外部类要访问内部类，必须建立内部类的对象。一把用于类的设计。分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。这时就是还有的事物定义成内部类来描述。*/class Outer{ private static int num = 31; class Inner// 内部类。 { void show() { System.out.println("show run..."+

原创 Java基础之多态中的成员变量，成员函数和静态函数

/*多态时，成员的特点：1，成员变量。 编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。 运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。 简单说：编译和运行都参考等号的左边。哦了。 作为了解。2，成员函数(非静态)。 编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。 运行时：参考的是对象所属的类中是否有调用的函数。 简单说：编译看左边，运行看右边。 因为成员函数存..

原创 Java基础之多态的转型

/*毕老师和毕姥爷的故事。*/class 毕姥爷{ void 讲课() { System.out.println("管理"); } void 钓鱼() { System.out.println("钓鱼"); }}class 毕老师 extends 毕姥爷{ void 讲课() { System.out.println("Java"); } void 看电影() { System.out.println("看电影"); }}class..

原创 Java基础之多态的概述和好处

/*对象的多态性。class 动物{}class 猫 extends 动物{}class 狗 extends 动物{}猫 x = new 猫();动物 x = new 猫();//一个对象，两种形态。猫这类事物即具备者猫的形态，又具备着动物的形态。这就是对象的多态性。 简单说：就是一个对象对应着不同类型. 多态在代码中的体现： 父类或者接口的引用指向其子类的对象。多态的好处： 提高了代码的扩展性，前期定义的代码可以使用后期的内容。多态的弊端.

原创 Java基础之接口的应用

/*笔记本电脑使用。为了扩展笔记本的功能，但日后出现什么功能设备不知道。定义一个规则，只要日后出现的设备都符合这个规则就可以了。规则在java中就是接口。*/interface USB// 暴露的规则。{ public void open(); public void close();}class BookPC{ public static void main(String[] args) { useUSB(new UPan());//功能扩展了。 useUSB.

原创 Java基础之接口和抽象类的区别

/*抽象类和接口的异同点：相同点： 都是不断向上抽取而来的。不同点： 1，抽象类需要被继承，而且只能单继承。 接口需要被实现，而且可以多实现。 2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。 接口中只能定义抽象方法，必须由子类去实现。 3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。 接口的实现是 like a 关系，在定义体系额外功能。犬按功能分：有导盲犬，搜爆犬。abstract class .

原创 Java基础之接口的定义和特点

/*abstract class AbsDemo{ abstract void show1(); abstract void show2();}当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是 接口 interface。*///定义接口使用的关键字不是class，是interface./*对于接口当中常见的成员：而且这些成员都有固定的修饰符。1，全局常量: public static final 2，抽象方法。public abstract

原创 Java基础之抽象类的小练习

/*雇员示例：需求：公司中程序员有姓名，工号，薪水，工作内容。项目经理除了有姓名，工号，薪水，还有奖金，工作内容。对给出需求进行数据建模。分析：在这个问题领域中，先找出涉及的对象。通过名词提炼法。程序员： 属性：姓名，工号，薪水、 行为：工作。经理： 属性：姓名，工号，薪水，奖金。 行为：工作。程序员和经理不存在着直接继承关系，但是程序员和经理却具有共性内容。可以进行抽取。因为他们都是公司的雇员 可以将程序员和经理进行抽取.建立体系. *///描述雇员

原创 Java基础之抽象类的概述

/*抽象类：抽象：笼统，模糊，看不懂！不具体。特点：1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。 抽象方法必须定义在抽象类中。该类必须也被abstract修饰。2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。 否则，这个子类还是抽象类。1，抽象类中有构造函数吗？ 有，用于给子类对象进行初始化。 2，抽象类可以不定义抽象方法吗？ 可以的。 但是很少见，目的就是不.

原创 Java基础之final关键字

//继承弊端：打破了封装性。/*final关键字：1，final是一个修饰符，可以修饰类，方法，变量。2，final修饰的类不可以被继承。3，final修饰的方法不可以被覆盖。4，final修饰的变量是一个常量，只能赋值一次。 为什么要用final修饰变量。其实在程序如果一个数据是固定的， 那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。 而且这个变量名称的值不能变化，所以加上final固定。 写法规范：常量所有字母都大写，多个单词，中间用_连接。*/c

原创 Java基础之父子类中子类的实例化过程

class Fu{ Fu() { super(); show(); return; } void show() { System.out.println("fu show"); }}class Zi extends Fu{ int num = 8; Zi() { super(); //-->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后， //才进行子类的成员变量显示初始化。 System.o

原创 Java基础之父子类中子类的实例化过程

/*子父类中的构造函数的特点。在子类构造对象时，发现，访问子类构造函数时，父类也运行了。为什么呢？原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。 为什么子类实例化的时候要访问父类中的构造函数呢？那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。所以子类在构造对象时，必须访问父类中的构造函数。 为什么完成.

原创 Java基础之父子类中成员函数的特点

//成员函数。/*当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作。这时函数在子父类中的特性。函数两个特性： 1，重载。同一个类中。overload 2，覆盖。子类中。覆盖也称为重写，覆写。override 覆盖注意事项：1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。 2，静态只能覆盖静态，或被静态覆盖。*/class Fu{ public static void show() { System.out.prin.

原创 Java基础之父子类中成员变量的特点和内存图解

/*在子父类中，成员的特点体现。1，成员变量。2，成员函数。3，构造函数。*///1，成员变量。/*当本类的成员和局部变量同名用this区分。当子父类中的成员变量同名用super区分父类。this和super的用法很相似。this:代表一个本类对象的引用。super：代表一个父类空间。*/class Fu{ private int num = 4; public int getNum() { return num; }}class ..

原创 Java基础之继承的定义

/*继承的好处： 1，提高了代码的复用性。 2，让类与类之间产生了关系，给第三个特征多态提供了前提.java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。单继承：一个子类只能有一个直接父类。多继承：一个子类可以有多个直接父类(java中不允许,进行改良) 不直接支持，因为多个父类中有相同成员，会产生调用不确定性。 在java中是通过"多实现"的方式来体现。java支持多层(多重)继承。C继承B，B继承A。就会出现继承体系。当要使用一个继承体.

原创 Java基础之单例设计模式及其内存图解

/*设计模式：对问题行之有效的解决方式。其实它是一种思想。1,单例设计模式。 解决的问题：就是可以保证一个类在内存中的对象唯一性。必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。如何保证对象唯一性呢？1，不允许其他程序用new创建该类对象。2，在该类创建一个本类实例。3，对外提供一个方法让其他程序可以获取该对象。步骤：1，私有化该类构造函数。2，通过new在本类中创建一个本类对象。3，定义一个公有的方法，将创建的对象返回。*///饿汉式cl.

原创 Java基础之数组工具类和文档注释的使用❤❤

ArrayToolDemoclass ArrayToolDemo { /* 保证程序的独立运行。 */ public static void main(String[] args) { int[] arr = {4,8,2,9,72,6};// ArrayTool tool = new ArrayTool();// int max= ArrayT8ool.getMax(arr);// System.out.println("max="+max); int ind

原创 Java基础之静态代码块

/*静态代码块。随着类的加载而执行。而且只执行一次。作用： 用于给类进行初始化。*/class StaticCode{ static int num ; static { num = 10;// num *=3; System.out.println("hahahah"); } StaticCode(){} static void show() { System.out.println(num); }}class Person{ pri.

原创 Java基础之static关键词啥时候使用？

/*静态什么时候用？1，静态变量。 当分析对象中所具备的成员变量的值都是相同的 。 这时这个成员就可以被静态修饰。 只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。 如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。2，静态函数。 函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。 简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。 如果不需要，就可以将该功

原创 Java基础之static内存图解❤❤

class Person{ private String name; private int age; static String country = "CN"; public Person(String name,int age) { this.name = name; this.age = age; } public void show() { System.out.println(Person.country+":"+this.name+":"+this.age);.

原创 Java基础之main函数解析

/*public static void main(String[] args) 主函数特殊之处：1，格式是固定的。2，被jvm所识别和调用。public:因为权限必须是最大的。static:不需要对象的,直接用主函数所属类名调用即可。void：主函数没有具体的返回值。main:函数名，不是关键字，只是一个jvm识别的固定的名字。String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。*/class MainDemo { public

原创 Java基础之static关键字

class Person{ String name;//成员变量，实例变量 static String country = "CN";//静态变量。类变量 public void show() { System.out.println(Person.country+":"+this.name); }}/*static的特点：1，static是一个修饰符，用于修饰成员。2，static修饰的成员被所有的对象所共享。3，static优先于对象存在，因为static的成员随着.

原创 Java基础之this关键字

/*当成员变量和局部变量重名，可以用关键字this来区分。this : 代表对象。代表哪个对象呢？当前对象。 this就是所在函数所属对象的引用。 简单说：哪个对象调用了this所在的函数，this就代表哪个对象。this也可以用于在构造函数中调用其他构造函数。注意：只能定义在构造函数的第一行。因为初始化动作要先执行。*/class Person{ private String name; private int age; Person() { na..

原创 Java基础之构造函数

class Person{ private String name; private int age; //定义一个Person类的构造函数。 Person()//构造函数，而且是空参数的。 { name = "baby"; age = 1; System.out.println("person run"); } //如果有的孩子一出生就有名字。 Person(String n) { name = n; } public void setN...