vb在调用模块里public声明的子程序（sub）时如何将调用子程序的代码所在的窗体代入？_百度知道
vb在调用模块里public声明的子程序（sub）时如何将调用子程序的代码所在的窗体代入？
例如我想写一个public sub 让一个form的backcolor=vbblack，然后把这个子程序放在一个模块里，但是我不知道是哪个form里的代码调用的子程序也就不知道该把那个form变黑，请问可以通过什么方法知道是哪个form调用的子程序吗？
我有更好的答案
设置全局变量Dim callname as string.....，只要显示callname就知道是哪个from调用的了啊. 再一个想要知道是那个From调用的，你只要设置一个全局变量，在调用前把调用的窗口写入即可啊。同上面的. 子程序里;From2：From2，Backcolor就设置好了，根本不需要什么子程序.. 在打开的From2....，你可在调用前直接设置即可，如下.Backcolor=VbBlackFrom2.Show 1首先我觉得你可能想多了，比如From1调用From2：callname = &From1&quot，想让From2的backcolor=vbblack.Backcolor=VbBlackFrom2.Show 1 这样就能在打开 From2 时
我的程序不是那么简单的……只是举个例子……就是做了一个碰撞的判定，但是可能在每个form里都会用到判定，所以想把判定写为一个public函数，但是这个判定涉及到单个form内的控件的操作，所以我需要知道是哪个form调用的函数……我应该不能通过一个string.command来操作……
多个调用，那你设置多个变量好了，那个变量有变化，执行对应的好了啊。
嗯，最后我设置了一个public object 变量，调用之前先给object赋值做到了，谢谢回答
采纳率：82%
为您推荐：
其他类似问题
sub的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。C#如何在工程中 定义 public、private
C#如何在工程中 定义 public、private
公有成员public member 在程序的任何地方都可以被访问实行信息隐藏的类将其public 成员限制在成员函数上这种函数定义了可以被一般程序用来操纵该类类型对象的操作 私有成员private member 只能被成员函数和类的友元访问实行信息隐藏的类把其数据成员声明为private 被保护成员protected member 对派生类derived class 就像 public 成员一样对其他程序则表现得像private 在类的private:节中声明的成员（无论数据成员或是成员函数）仅仅能被类的成员函数和友元访问. 在类的protected: 节中声明的成员（无论数据成员或是成员函数）仅仅能被类的成员函数,友元以及子类的成员函数和友元访问. 在类的public:节中声明的成员（无论数据成员或是成员函数）能被任何人访问. public、private或proteced,它们控制变量成员和成员函数在类内和类外如何访问.所谓类内访问是指用类的成员函数进行访问,而类外访问是指用对象或指向对象的指针进行访问. 当一个类的成员定义为public,就能够在类外访问,包括它的派生类. 当一个成员定义为private,它仅能在类内访问,不能被它的派生类访问. 当一个成员定义为proteced,它仅能在类内访问,但是能被它的派生类访问. 当一个成员没有指定访问说明符时,默认为private. 在定义派生类时,访问说明符也能出现在基类的前面,它控制基类的变量成员和成员函数在派生类中的访问方法.当访问说明符为public时,称为公有继承.同样地,当问说明符为protected时,称为保护继承,而当问说明符为private时,称为私有继承. 公有继承时,基类的公有成员,变为派生类的公有成员,基类的保护成员,变为派生类的保护成员. 保护继承时,基类的公有和保护成员,均变为派生类的保护成员. 私有继承时,基类的公有和保护成员,均变为派生类的私有成员.
与《C#如何在工程中 定义 public、private》相关的作业问题
import java.util.*;class TestPoint{public double distance(Point p1,Point p2){return Math.sqrt(Math.pow(p1.getX()-p2.getX(),2)+Math.pow(p1.getY()-p2.getY(),2));}
默认是Public的在 Class 块中,成员通过相应的声明语句被声明为 Private 或 Public.被声明为 Private 的将只在 Class 块内是可见的.被声明为 Public 不仅在 Class 块的内部是可见的,对 Class 块之外的代码也是可见的.没有使用 Private 或 Public 明确
其实这些都定义的作用域,例如有个class A{ //没有限制 public void abc(){ System.out.println("public"); } //本包下调用 protected void abc2(){ System.out.println("protected"); } //只能在本类中调用
其他的锚杆还有插入式中空锚杆,预应力中空锚杆,组合式中空锚杆等,使用情况要根据岩层设计要求而定的,这个有什么不明白的 也可以电话给我,我们公司是专业生产中空锚杆的厂家,用户名即是我的电话,
解答这个问题时先说明你所举例的损耗与有人说的损耗是两个不同的概念.你所举例的损耗是某个分项目的实际损耗,而理论重量还要再乘以损耗率中的损耗是指定额损耗.1、一般造价做预决算,均是指定额损耗,定额损耗是一个固定的数值,通过现场技术测定法、实验室试验法、现场统计法等方法为依据编制材料损耗定额.2、要完成一个需要消耗材料的具
是个类,origin是类成员变量
类的成员变量通常定义为private类型,而类的成员函数通常定义为public类型
class A{public Bd = new B();public B getB（）{return d；}}class C{}{A a = new A（）；a.getB();}能获得A的对象么 再问： 我是菜鸟，不太清楚。我有疑问，我的对象d在类A中已经实例化了，在类c中再new一个a，这样得到的d跟类A中的d
温度效应分为线性温度及非线性温度效应.线性温度效应指的是桥梁结构整体升温降温造成的温度应力.一般数值比较小.非线性温度指的是桥梁结构受到不均匀温度变化的温度应力,例如离上面板10cm升温14度,离30cm升温7度,这样产生的结构截面上面与下面结构应力不等产生结构应力,数值比较大,跟桥梁的刚度,截面属性有关.希望能帮到你
轴测图是一种单面投影图,在一个投影面上能同时反映出物体三个坐标面的形状,并接近于人们的视觉习惯,形象、逼真,富有立体感.但是轴测图一般不能反映出物体各表面的实形,因而度量性差,同时作图较复杂.因此,在工程上常把轴测图作为辅助图样,来说明机器的结构、安装、使用等情况,在设计中,用轴测图帮助构思、想象物体的形状,以弥补正投
软化系数：岩石充分吸水后的抗压（拉）应力与干燥状态下抗压（拉）应力之比 塑性：介质受压（拉）后的变形有一部分不可恢复,称为塑性莫尔应力：介质中任一点三个主应力状态在坐标系中可以组成一个圆,称为莫尔应力圆
驳船本身无自航能力,需拖船或顶推船拖带的货船.其特点为设备简单、吃水浅、载货量大.驳船一般为非机动船,与拖船或顶推船组成驳船船队,可航行于狭窄水道和浅水航道
饱和度：定义1：指物体颜色的包含量或纯度. 应用学科：测绘学（一级学科）；地图制图学（二级学科） 定义2：土体中孔隙水体积与孔隙体积之比值. 应用学科：水利科技（一级学科）；岩石力学、土力学、岩土工程（二级学科）；土力学（水利）（三级学科） 交通术语： 　　描述道路或交叉口的交通负荷程度的指标,由道路或交叉口的交通流量
通俗地说一下,水流从一面向另一面有渗透的趋势.这个第一面,即迎水面.如地下室的外墙,当地下水从外面向里面有渗透的趋势时,外面即迎水面.如水箱,里面的水有向外渗透的趋势,里面即为迎水面.如地下一水箱.地下水有从外向水箱内渗透的趋势,而水箱内的水也有向外渗透的趋势,则二个面都是迎水面.
private Socket socket只是声明了一个 Socket类型的对象,而且访问权限是private,当然现在还没有被初始化.需要你自己实例.Socket socket=new Socket则不仅声名了一个Socket,而且已经帮你实例化好了,直接用就可以了.
Class AC{//函数1：private int sum1(int s1,int s2){return s1+s2;}//函数2private void ddd(){ggg = sum1(2,3); //此处调用sum1的计算结果}//函数1、2不能为:public AC(
位数多了截取一下不就完了吗? 再问： 所有的数据都要输出打印 截取不好操作吧 再答： 用字符型就可以搞定了！~ 数据是从数据库取出来的吗？再问： 不是 是矩阵算出来的 我就是不知道 定义变体的时候怎么定义 再答： dim a 这样不写类型就是变体型的 Dim a As Variant 这样写也可以再问： 怎么把变体设置
#include #include class L // 预声明线类 class Point { public:Point(int x,int y) { m_x = m_y = } private:int m_x; int m_y; friend class
把这三个类分别放到三个.java文件中,然后编译运行即可.public class Circle{ public Circle(double r){ this.r = } public double getZhou(){ return 2*Math.PI*r; } public黑马程序员_java基础笔记(03)...面向对象
时间： 21:22:34
&&&& 阅读：186
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&　　----------------------&&、、期待与您交流！ ----------------------&&
1：面向对象的概念，2&：&类和对象的关系，3&：&封装，4&：&构造函数，5&：&this关键字，6&：&static关键字，
7&：&单例设计模式，8&：&继承，9&：&抽象类，10&：&接口，11&：&多态，12&：&Object类，13&：&内部类，
14&：&异常，15&：&包
1:面向对象的概念
a:面向对象是相对面向过程而言
b:面向对象和面向过程都是一种思想
c:面向过程强调的是功能行为
d:面向对象将功能封装进对象，强调具备了功能的对象。
e:面向对象是基于面向过程的。
面向对象：三个特征：封装，继承，多态。
开发：其实就是&找对象，建立对象，使用对象。维护对象的关系。
2:类与对象的关系
类：对现实生活中事物的描述。&
对象：这类事物，实实在在存在个体。
在内存中的位置：&
　　成员变量：在堆内存中，因为对象的存在，才在内存中存在。&
　　局部变量：存在栈内存中。
　　匿名对象使用方式一：对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。如果一个对象进行多个成员调用，必须给这个对象起个名字。&
　　匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
3:封装（Encapsulation）
a:封装：是指隐藏对象的属性和现实细节，仅对外提供公共访问方式。
b:好处：将变化隔离，便于使用，提高重要性，提高安全性
c:封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方法对其访问。
　　之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。
　　对访问的数据进行操作。提高代码健壮性。
:私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。&私有只在本类中有效。
&&私有仅仅是封装的一种表现形式。
类中的属性通常被私有化，并对外提供公共的访问方法。这样可以避免安全隐患。
这个方法一般有两个，规范写法：对于属性&xxx，可以使用setXxx(),getXxx()对其进行操作。
4:构造函数
　　a:函数名与类名相同
　　b:不用定义返回值类型
　　c:不可以写return语句
作用：给对象进行初始化。
　　多个构造函数是以重载的形式存在的，当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。&
构造函数和一般函数在写法上有不同。在运行上也有不同。
　　构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。
什么时候定义构造函数呢？
　　当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块。
作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
　　构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
　　构造代码块中定义的是不同对象共性的初始化内容。
p = new Person();
该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。
5:this关键字
this代表它所在函数所属对象的引用，哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
但凡本类功能内部使用了本类对象，都用this表示。this语句 :用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。
static void main(String[] args)&
主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[]
arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的：jvm识别。
jvm在调用主函数时，传入的是new
String[0];
6.static关键字
static关键字：用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：随着类的加载而加载，优先于对象存在，被所有对象所共享，可以直接被类名调用
使用注意：静态方法只能访问静态成员，静态方法中不可以写this，super关键字
static用法：是一个修饰符，用于修饰成员(成员变量，成员函数).
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，&
还可以直接被类名调用。类名.静态成员。
实例变量和类变量的区别：
　　1，存放位置。类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。
　　2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。&可以直接被类名调用。
弊端：生命周期过长。&访问出现局限性。(静态虽好，只能访问静态。)
应用：构造函数需要私有化
　　函数被静态修饰被提供外界使用
静态代码块。
静态代码块中的执行语句。
特点：随着类的加载而执行，只执行一次,并优先于主函数。 用于给类进行初始化的。
静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块&构造函数；
生成Java帮助文档：命令格式：javadoc&–df:\&myhelp&–auther&–version&ArrayTool.java
-d当前目录& -df:\存到f:\下&& ArrayTool必须public修饰
&这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。
@author 张三
@version V1.1
public class ArrayTool {
　　/** 空参数构造函数。 */
　　private ArrayTool(){}
　　/** 获取一个整形数组中的最大值。
　　@param arr 接收一个int类型的数组。
　　@return 会返回一个该数组中最大值。 */
　　public static int getMax(int[] arr) {
　　　　int max = 0;
　　　　for(int x=1; x&arr. x++) {
　　　　　　 if(arr[x]&arr[max]) max =
　　　　 }
　　　　return arr[max];
7:单例设计模式
单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。
要保证对象唯一&
　　1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象&
　　2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
　　3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。&
这三部怎么用代码体现呢？&1，将构造函数私有化。&2，在类中创建一个本类对象。&3，提供一个方法可以获取到该对象。
设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式（Factory Method）、抽象工厂模式（Abstract Factory）、
单例模式（Singleton）、建造者模式（Builder）、原型模式（Prototype）。
结构型模式，共七种：适配器模式（Adapter）、装饰器模式（Decorator）、代理模式（Proxy）、
外观模式（Facade）、桥接模式（Bridge）、组合模式（Composite）、
享元模式（Flyweight）。
行为型模式，共十一种：策略模式（strategy）、模板方法模式（Template Method）、
&&观察者模式（Observer）、迭代子模式（Iterator）、
&责任链模式（Chain of Responsibility）、命令模式（Command）、
备忘录模式（Memento）、状态模式（State）、访问者模式（Visitor）、
& &中介者模式（Mediator）、解释器模式（Interpreter）。
其实还有两类：
并发型模式和线程池模式。
记录原则：定义单例，建议使用饿汉式。
先初始化对象。称为：饿汉式。Single类一进内存，就已经创建好了对象。
class Single{
　　//&在类中创建一个本类对象
　　private
static Single s = new Single();
　　// 将构造函数私有化
　　private
Single(){ }
　　//&提供一个方法可以获取到该对象
　　public static Single
getInstance(){
　　　　return
对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single{
　　private
static Single s =
　　private
Single(){ }
　　public static Single
getInstance(){
　　　　if(s==null){
　　　　　　//&加了一个锁
　　　　　　synchronized(Single.class){
　　　　　　　　if(s==null)
　　　　　　　　s
= new Single();
　　　　　　}
　　　　return
8:继承（extends）
继承的特点
　　1，提高了代码的复用性。
　　2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
&&java支持多层继承。也就是一个继承体系
子父类出现后，类成员的特点：
如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。子类要访问父类中的同名变量，用super。
super关键字&
　　this代表的是本类对象的引用。&
　　super代表的是父类对象的引用。
super()和this()是否可以同时出现的构造函数中。
两个语句只能有一个定义在第一行，所以只能出现其中一个。
super()或者this():为什么一定要定义在第一行？
因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。
2,子父类中的函数。
当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖)。当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
　　1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
　　2，静态只能覆盖静态。
3，子父类中的构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句
super();。
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数。
　　因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。super语句一定定义在子类构造函数的第一行。
子类的实例化过程
　　子类的所有的构造函数，默认都会访问父类中空参数的构造函数。当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
final关键字最终作为一个修饰符。
　　1，可以修饰类，函数，变量。
　　2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
　　3，被final修饰的方法不可以被复写。
　　4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。
　　5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
9:抽象类&(abstract)
抽象类的特点：
　　1，抽象方法一定在抽象类中。
　　2，抽象方法和抽象类都必须被abstract关键字修饰。
　　3，抽象类不可以用new创建对象。因为调用抽象方法没意义。
　　4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
与abstract不能共存的关键字。
　　final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
　　private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
　　static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
模版方法设计模式。
　　在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。
10:接口&(interface
接口：初期理解，可以认为是一个特殊的抽象类当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
用于定义接口。
接口定义时，格式特点：
　　1，接口中常见定义：常量，抽象方法。
　　2，接口中的成员都有固定修饰符。
常量：public
static final
方法：public
接口中的成员都是public的。
接口的特点：
　　接口是对外暴露的规则
　　接口是程序的功能扩展
　　接口可以用来多实现
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
　　接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
定义：某一类事物的多种存在形态。
1，多态的体现
　　父类的引用指向了自己的子类对象。
　　父类的引用也可以接收自己的子类对象。
2，多态的前提
　　必须是类与类之间有关系。要么继承，要么实现。
　　通常还有一个前提：存在覆盖。
3，多态的好处
　　多态的出现大大的提高程序的扩展性。
4，多态的弊端：
　　提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5，多态的应用&
　　equals()&
6，多态的出现代码中的特点(多态使用的注意事项)
　　我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
多态自始至终都是子类对象在做着变化。
&instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)
在多态中成员函数的特点：
　　在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
　　在运行时期：参阅对象所属的类中是否有调用的方法。
在多态中，成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类)。
在多态中，静态成员函数的特点：无论编译和运行，都参考做左边。
12.Object类
Object:是所有对象的直接或者间接父类。该类中定义的肯定是所有对象都具备的功能。Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
equals方法&指示其他某个对象是否与此对象“相等”
toString方法返回该对象的字符串表示
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）
内部类的访问规则：
　　1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，
格式&外部类名.this
　　2，外部类要访问内部类，必须建立内部类对象。
　　访问格式：
　　　　①,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中,直接建立内部类对象。
　　　　格式
　　　　外部类名.内部类名
&变量名 = 外部类对象.内部类对象;
　　　　Outer.Inner in = new Outer().new
　　　　②,当内部类在成员位置上，就可以被成员修饰符所修饰。
　　比如，private：将内部类在外部类中进行封装。
内部类具备static的特性。
　　当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
　　在外部其他类中，如何直接访问static内部类的非静态成员呢？
　　new Outer.Inner().function();
　　在外部其他类中，如何直接访问static内部类的静态成员呢？
　　Outer.Inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static的。&当外部类中的静态方法访问内部类时，内部类也必须是static的。
内部类定义在局部时，
　　1，不可以被成员修饰符修饰
　　2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类:
　　1，匿名内部类其实就是内部类的简写格式。
　　2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
　　3，匿名内部类的格式：
&new 父类或者接口(){定义子类的内容}
　　4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
　　5，匿名内部类中定义的方法最好不要超过3个。
interface Inter{
class Test&{
　　//补足代码。通过内部类。
　　static
class Inner implements Inter{
　　　　public void
　　　　　　System.out.println("method
　　static
Inter function(){
　　　　return new Inner();
　　//补足代码。通过匿名内部类。
　　static
Inter function(){
　　　　return new
　　　　　　public void
　　　　　　　　System.out.println("method
　　　　　　}
　　　　};
class InnerClassTest&{
　　public static void main(String[]
　　　　Test.function().method();
&&& &&&//&=&&
&&&Inter in =
Test.function();
　　　　　　　　　　　　　　　　　// &&
&in.method();
　　　　Test.function():&
//Test类中有一个静态的方法function。
　　　　method():&&
//&function这个方法运算后的结果是一个对象。而且是一个Intger类型的对象。
　　　　　　　　　//因为只有是Inter类型的对象，才可以调用method方法。
匿名内部类:&class
InnerClass{
　　public static void main(String[]
　　　　show(new
　　　　　　public void method(){
　　　　　　　　System.out.println("method
show run");
　　　　　　}
　　　　});&&&}是子类代码结束)是参数结束;是这条语句结束
public static void show(Inter in){
　　in.method();
class InnerTest{
　　public static void main(String[] args){
　　　　new
Object()&{&&&&&//new
Object();创建了一个上帝 //new Object(){
}Object的子类对象
　　　　　　public void function(){
　　　　　　}
　　　　}.function();
异常：是什么？是对问题的描述。将问题进行对象的封装。
异常的体系
　　|--Error
　　|--Exception
　　　　|--RuntimeException
　　通常出现重大问题如：运行的类不存在或者内存溢出等
　　不缩写针对代码对其处理
②Exception
　　在运行时运行出现的一起情况，可以通过try
catch finally
异常的处理
提供了特有的语句进行处理。
　　try&{&需要被检测的代码；}
　　catch ( 异常类 变量 )&{&处理异常的代码；(处理方式)&}
　　finally&{&一定会执行的语句；&}
有三个结合格式：
finally{&}
finally{&}
　　1，finally中定义的通常是
关闭资源代码。因为资源必须释放。
　　2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
throws关键字，声明该功能有可能会出现问题
throw和throws的用法：
　　throw定义在函数内，用于抛出异常对象。
　　throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。
异常有两种：
编译时被检测异常
　　该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
　　该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
　　在编译时，不需要处理，编译器不检查。
　　该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
对捕获到的异常对象进行常见方法操作。
String &getMessage()：获取异常信息。
toString()& &// 异常名称 ：
异常信息。
printStackTrace()&
&//异常名称，异常信息，异常出现的位置。
//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
//打印异常的堆栈的跟踪信息。
对多异常的处理。
　　1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
　　2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。在进行catch处理时，catch中一定要定义具体处理方式。也不要简单的就书写一条输出语句。
自定义异常：
定义类继承Exception或者RuntimeException
　　1,为了让该自定义类具备可抛性。
　　2，让该类具备操作异常的共性方法。
当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。
class MyException
extends Exception{
　　MyException(String message){
　　　　super(message);
自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。
异常的好处：
　　1，将问题进行封装。
　　2，将正常流程代码和问题处理代码相分离，方便于阅读。
异常的处理原则：
　　1，处理方式有两种：try
或者 throws。
　　2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。
　　3，多个catch，父类的catch放到最下面。
　　4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
new AException();
catch (AException e){
如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。
new AException();
catch (AException e){
对AException处理。
new BException();
异常的注意事项：
在子父类覆盖时：
　　1，子类抛出的异常必须是父类的异常的子类或者子集。
　　2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
（package）
①对类文件进行分类管理
②给类提供多层命名空间
③写在程序文件的第一行
④类名的全称是
&包名.类名
⑤包也是一种封装形式
为了简化类名的书写，使用一个关键字，import.
建议，不要写通配符 * ，需要用到包中的哪个类，就导入哪个类。
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种，public
&protected（保护）。
权限） &&& &&public & &protected & & &
default & & private
同一个类中
& & ok & & & & & & ok & &
& & & & & &ok & & & &
同一个包中
& & ok & & & & & & ok & &
& & & & & &ok
子类 & & & &
&&&&& &ok & & & & & & ok
& & & & & &&
& & & & ok
: java的核心包 jdk1.2版本以后，该包中的类自动导入。
用于制作图形界面。
用于操作设备上的数据。
: 这里定义是java的工具类。集合，日期。
java.net:用于网络通讯的。
&----------------------&&、、期待与您交流！
----------------------&&
&&标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&原文：http://www.cnblogs.com/In-order-to-tomorrow/p/3528517.html
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！}