java内部类,异常--09

Postman账号 Postman账号一、为什么要注册一个Postm账号二、如何注册Postman账号三、登录账号四、切换账号五、找回账号密码 一、为什么要注册一个Postm账号 注册Postman账号是免费的。当注册并登录一个Postman账号后,用户可以获得一下权限。 (1)同步和备份历史、集合、环境和预置头。 (2)可以轻松处理来自不同机器的多个Postman实例‘ (3)创建集合链接发送给其他开发人员。 当然,不注册也可以使用Postman。 二、如何注册Postman账号 (1)下载、安装Postman应用程序。 ( 阅读详情

内部类

内部类的访问规则:
1,内部类可以直接访问外部类中的成员,包括私有
格式:外部类名.this

2,外部类要访问内部类,必须建立内部类对象。
访问格式:
1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中直接建立内部类对象。
格式:外部类名.内部类 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();

2,当内部类在成员位置上,就可以被成员修饰符修饰
比如,private:将内部类在外部类中进行封装。
static:内部类可以被静态修饰,就具备了静态的特性
当内部类被static修饰后,只能直接访问外部类中的静态成员。出现了访问局限。

在外部其他类中,如何直接访问静态内部类的非静态成员呢?
new Outer.Inner().function();

在外部其他类中,如何直接访问静态内部类的静态成员呢?
Outer.Inner.function();

注意:
当内部类中定义了静态成员,该内部类必须是静态的。
当外部类中的静态方法访问到内部类时,内部类也必须是静态的。

class Outer
{
    private int x=3;

    class Inner //内部类
    {
        int x=4;
        void function()
        {
            int x=6;
            System.out.println("inner:"+Outer.this.x);
            //打印结果是3,里面换成this.x打印的是4,直接打印x是6
        }
    }

    void method()
    {
        Inner in = new Inner();
        in.function();
    }
}

class InnerClassDemo
{
    public static void main(String[] args)
    {
        //Outer out = new Outer();
        //out.method();

        //直接访问内部类中的成员
        Outer.Inner in = new Outer().new Inner();
        in.function();
    }
}

内部类定义在局部时,
1,不可以被成员修饰符修饰。如static
2,可以直接访问外部类中的成员,因为还持有外部类中的引用
但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量。

class Outer
{
    int x = 3;
    void method(final int a)
    {
        final int y = 4;
        class Inner
        {
            void function()
            {
                System.out.println(a);
            }
        }   

        new Inner().function();
    }
}

class InnerClassDemo3
{
    public static void main(String[] args)
    {
        //new Outer().method();
        Outer out = new Outer();
        out.method(7);
        out.method(8);
    }
}

匿名内部类

1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:
内部类必须是继承一个类或者实现接口
3,匿名内部类的格式:new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象。带内容的对象。
5,匿名内部类中定义的方法最好不要超过三个。

abstract class AbsDemo
{
    abstract void show();
}

class Outer
{
    int x = 3;
    /*
    class Inner extends AbsDemo
    {
        void show()
        {
            System.out.println("method:"+x);
        }
    }
    */
    public void function()
    {
        //new Inner().show();
        new AbsDemo()//匿名内部类
        //AbsDemo ab = new AbsDemo()
        {
            void show()
            {
                System.out.println("x="+x);

            }
        }.show();

    }
}

class InnerClassDemo4
{
    public static void main(String[] args)
    {
        new Outer().function();
    }
}

这里写图片描述

练习:

class Test
{
    //补足代码,通过匿名内部类。
    /*
    static class Inner implements Inter
    {
        public void method()                //这是有名字的方法,效果与下面的匿名方法一样
        {
            System.out.println("method run");
        }
    }
    */
    static Inter function()
    {
        return new Inter()
        {
            public void method()
            {
                System.out.println("method run");
            }
        };
    }
}

class InnerClassTest
{
    public static void main(String[] args)
    {

        //Test.function():Test类中有一个静态的方法function。
        //.method():function这个方法运算后的结果是一个对象,而且是一个Inter类型的对象。
        //因为只有是Inter类型的对象,才可以调用method方法。
        Test.function().method();


        Inter in = Test.function();
        in.method();

    }


}

这里写图片描述

异常

异常:程序在运行时出现的不正常情况。
异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述,并封装成对象。 也就是java对不正常情况进行描述后的对象体现。

对于问题的划分:一种是严重的问题,一种是非严重的问题。
对于严重的,java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
对于非严重的,java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容
比如:不正常情况的信息:引发原因等

Throwable
|–Error
|–Exception

2,异常的处理

java提供了特有的语句进行处理

try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常的代码;(处理方式)
}
finally
{
一定会执行的语句;
}

3,对捕获到的异常对象进行常见方法操作
String getMessage():获取异常信息

class Demo
{
    int div(int a,int b)
    {                                           
        return a/b;
    }
}

class ExceptionDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,0);
            System.out.println("x="+x);

        }
        catch(Exception e)//Exception e = new ArithemeticException();
        {
            System.out.println("feifa");
            System.out.println(e.getMessage());//   /by zero
            System.out.println(e.toString());//异常名称:异常信息

            e.printStackTrace();//异常名称,异常信息,异常出现的位置。
                                //其实jvm默认的异常处理机制,就是在调用printStackTrace方法。
                                //打印异常的堆栈的跟踪信息。

        }
        System.out.println("over");
    }
}

这里写图片描述

在函数上声明异常。
便于提高安全性,让调用者进行处理,不处理编译失败。
1,要么抛出去

class Demo
{
    int div(int a,int b) throws Exception//在功能上通过throws的关键字声明了
                                         //该功能可能会有的问题
    {                                    //把问题抛出去
        return a/b;
    }

}

class ExceptionDemo
{
    public static void main(String[] args) throws Exception
    {
        Demo d = new Demo();

        int x = d.div(4,0);
        System.out.println("x="+x);

        System.out.println("over");
    }
}

这里写图片描述

要么try,catch处理

class Demo
{
    int div(int a,int b) throws Exception//在功能上通过throws的关键字声明了
                                         //该功能可能会有的问题
    {                                    //把问题抛出去
        return a/b;
    }

}

class ExceptionDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,0);
            System.out.println("x="+x);

        }
        catch(Exception e)//Exception e = new ArithemeticException();
        {
            System.out.println("feifa");

            System.out.println(e.toString());//异常名称:异常信息

        }
        System.out.println("over");
    }
}

这里写图片描述

对多异常的处理
1,声明异常时,建议声明更为具体的异常,这样处理的更具体。
2,对方声明几个异常,就对应有几个catch块,不要定义多余的catch块
如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面

建议在进行catch处理时,catch中一定要定义具体处理方式。
不要简单定义一句e.printStackTrace(),
也不要简单的书写一条输出语句。

自定义异常

因为项目中会出现特有的问题,
而这些问题并未被java所描述并封装对象
所以对于这些特有的问题可以按照java的对问题封装的思想
将特有的问题,进行自定义的异常封装。

自定义异常

需求:在本程序中,对于除数是负数,也认为是错误的,是无法进行运算的
那么就需要对这个问题进行自定的描述

当在函数内部出现throw抛出异常对象,那么就必须要给对应的处理动作。
要么在内部try catch处理
要么在函数上声明让调用者处理。

一般情况下,函数内出现异常,函数上需要声明。

class FuShuException extends Exception
{
}

class Demo
{
    int div(int a,int b)throws FuShuException
    {
        if(b<0)
            throw new FuShuException();//手动通过throw关键字抛出一个自定义异常对象。

        return a/b;
    }
}

class ExceptionDemo3
{
    public static void main(String[] args)
    {
        Demo d = new Demo();

        try
        {
            int x = d.div(4,-1);
            System.out.println("x="+x);
        }

        catch (FuShuException e)
        {
            System.out.println(e.toString());
            System.out.println("除数是负数");


        }


        System.out.println("over");
    }
}

这里写图片描述

发现打印的结果中只有异常的名称,没有异常的信息
因为自定义的异常并未定义信息

如何定义异常信息呢?

因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时,将异常信息传递给父类通过super语句
那么就可以直接通过getMessage方法获取自定义的异常信息

class FuShuException extends Exception 
{
    private int value;

    FuShuException(String msg,int value)
    {
        super(msg);
        this.value = value;
    }
    public int getValue()
    {
        return value;
    }
}

class Demo
{
    int div(int a,int b)throws FuShuException
    {
        if(b<0)
            throw new FuShuException("/ by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。

        return a/b;
    }
}

class ExceptionDemo3
{
    public static void main(String[] args)
    {
        Demo d = new Demo();

        try
        {
            int x = d.div(4,-1);
            System.out.println("x="+x);
        }

        catch (FuShuException e)
        {
            System.out.println(e.toString());

            System.out.println("错误的负数是:"+e.getValue());

        }

        System.out.println("over");
    }
}

这里写图片描述

自定义异常:必须是自定义类继承Exception

继承Exception原因
异常体系有一个特点:因为异常类和异常对象都被抛出
他们都具备可抛性。这个可抛性是Throwable这个体系的独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

throws和throw的区别
throws使用在函数上
throw使用在函数内

throws后面跟的是异常类,可以跟多个,用逗号隔开
throw后面跟的是异常对象。
——————————————————————————————
Exception中有一个特殊的子类异常RunTimeException(运行时异常)

特殊之处:
如果在函数内容抛出该异常,函数上可以不声明,编译一样通过
如果在函数上声明该异常,调用者可以不用进行处理,编译一样通过。

之所以不用在函数上声明,是因为不需要让调用者处理
当该异常发生,希望该程序停止,因为在运行时,出现了无法继续运算的情况,希望停止程序后,
对代码进行修正。

自定义异常时:如果该异常的发生,无法在继续进行运算
就让自定义异常继承RuntimeException

对于异常分两种,
1,编译时被检测的异常

2,编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

class FuShuException extends RuntimeException
{
    FuShuException(String msg)
    {
        super(msg);
    }
}

class Demo
{
    int div(int a,int b) //throws ArithmeticException
    {
        if(b<0)
            throw new FuShuException("出现了除数为负数了");
        if(b==0)
            throw new ArithmeticException("被零除了");
        return a/b;
    }
}

class ExceptionDemo4
{
    public static void main(String[] args)
    {
        Demo d = new Demo();

        int x = d.div(4,-9);
        System.out.println("x="+x);

        System.out.println("over");
    }
}

Isaac Lab & GR00T N1 入门教程(七)人形机器人推理与技能学习策略基准测试 本文介绍了IsaacLab设计的工业机器人操作评估系统,包含两项任务:螺母倾倒(成功率91%)和排气管分拣(成功率95%)。系统支持通过IsaacGR00TN1模型进行策略闭环评估,提供完整的开发环境配置指南(需Ubuntu22.04、CUDA12.8等环境),数据集下载方式(HuggingFace平台托管),以及模型微调流程。评估支持并行化测试(建议10-30个并行环境),并给出详细硬件配置建议(推荐RTX A6000 Ada显卡)。文档还包含常见问题解决方案,特别说明当前暂不支持Blackwell GP 阅读详情

相关推荐

Cadence仿真笔记(二):传统noise仿真—共源极的噪声

cadence中进行传统噪声仿真

Bao_xue的博客 1万+

内部类

一、内部类定义        内部类(nested classes),面向对象程序设计中,可以在一个类的内部定义另一个类。嵌套类分为两种,即静态嵌套类和非静态嵌套类。静态嵌套类使用很少,最重要的是非静态嵌套类,也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置,可以与实例变量处于同一级,或处于方法之内,甚至是一个表达式的一部分。   ...

qq_36777191的博客 302

【鼠标在不点击的情况下,直接移动到QT控件上不显示提示信息】

有时明明已经调用了setToolTips方法,鼠标移动到QT控件上仍然不会有提示信息,这时候就需要具体分析下。重点就是标红的这段话,大概意思就是。.h文件中加入鼠标移动事件的定义。.cpp文件中实现该事件。

ZTH_G的博客 2427

内部类的定义

1.内部类的定义 内部类是指在一个外部类的内部再定义一个类。 内部类可以是静态static的,也可用public,default,protected,private修饰。(而外部顶级类即类名和文件名相同的只能使用public和default)。 注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后

weixin_38955858的博客 1946

ubuntu 24.04安装ros1 noetic

上面是参考链接给的修改内容。除了上面要修改的地方,我在编译的生活还有一个地方报错,修改成如下形式。因为我已经对文件rosconsole_log4cxx.cpp作了上面的修改,所有是不是188行不太确认了,如果报“log4cxx::spi::LocationInfo”问题,按照下面修改就可以了。我在编译时还报了一个问题,就是我之前安装的是jazzy。所以在编译时会报ros变量名不对,这时对变量名做修改就可以了。具体怎么修改,百度。a、将源文件中所有CMakelist中编译标准改为c++ 17.

yangpan011的博客 3209

Anaconda+Pycharm安装

我提前创建好一个自己项目所需的虚拟环境。步骤是:打开终端(cmd)或者 搜索 ”Anaconda Prompt“ 并打开,输入 conda create -n pytorch python=3.9 -c。

Wang_sweet的博客 3235

Java基础——内部类

可以将一个类的定义放在另一个类的定义内部,这就是内部类。 使用内部类的好处: 允许你把一些逻辑相关的类组织在一起,并且可以控制内部类的对外访问权限 内部类是一种代码隐藏机制,同时内部类还了解外部类并且能够与外部类进行通信 1. 创建内部类 创建内部类的方式就是将内部类的定义放在外部类的定义中: public class Parcel { class Contents { private int i = 11; public int value() { .

qq_51964209的博客 3218

中移物联ML307C模组OPENCPU开发环境搭建全攻略

本文详细介绍了中移物联ML307C模组OPENCPU开发环境搭建的全过程。从OPENCPU模式的核心优势解析,到SDK获取、Python与scons工具安装,再到解读SDK目录结构与实战编译命令,最后提供常见问题避坑指南,帮助开发者快速构建高效的物联网应用编译环境。

weixin_29168393的博客 748

java内部类与异常类

java笔记内部类与异常类(超详细)!必读好文!

weixin_51976923的博客 718

如何解决Dify重新部署(升级到最新版)后出现的Setup failed: PermissionDenied等问题

重新部署(升级)Dify后遇到Permission denied错误?🚫 本文详细分析了这个问题的原因🔐,并提供了完整的解决步骤来修复这个问题✨

XiaoqiangClub的博客 1656

使用Microsoft Print to PDF进行编程:创建PDF文件的简单方法

Microsoft Print to PDF是一种内置于Windows操作系统中的功能,它允许我们通过打印操作将任何可打印的内容保存为PDF文件。然后,我们使用Microsoft Print to PDF打印机进行打印操作,并将输出文件保存为指定的PDF文件。使用Microsoft Print to PDF功能是一种方便且简单的方法来创建PDF文件,无论是在个人使用还是在企业开发中,它都可以提供良好的支持和灵活性。请注意,如果你使用的是其他编程语言,你可以根据相应的打印机接口或库来实现类似的功能。

TechSavant的博客 1636

java学习笔记——09内部类与异常类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类,嵌套其他类的类称为外部类。是我们类的第五大成员【思考:类的五大成员是哪些?属性,方法,构造器,代码块,内部类】,内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系在编写程序时可以扩展Exception类定义自己的异常类,然后根据程序的需要来规定哪些方法产生这样的异常。

昭与云的博客 1317

YOLO26涨点改进 | 全网独家复现、小目标检测改进篇 | TGRS 2025 | YOLO26引入MFAE-YOLO中的GFFP、FCPS 和 C3k2-FPEU创新点,涨点起飞,直接发论文

🔥本文给大家介绍在YOLO26中引入MFAE-YOLO中的 GFFP(全局特征融合处理)、FCPS(特征通道像素注意力) 和 C3k2-FPEU(特征池提取单元) 二次创新改进模块,能显著提升对小目标的检测性能。GFFP通过多尺度特征融合增强全局上下文感知能力,有效提升小目标在复杂背景下的可辨性;FCPS融合通道、像素和空间注意力机制,增强了模型对关键细节和小区域特征的关注,提升检测精度;C2F-FPEU利用多种池化方式挖掘细节特征,优化浅层特征表示能力。三者协同提升了YOLO26在小目标检测中的鲁棒性。

Ai缝合怪、助力小伙伴高效发论文 307

Java基础09:内部类;异常;final;

一、内部类     1、将一个类定义在另一个类的里面,对里面那个类就成为内部类(内置类,嵌套类)     2、访问特点、访问规则:         (1)、内部类可以直接访问外部类中的成员,包括私有成员         (2)、而外部类要访问内部类中的成员必须要建立内部类的对象         (3)、之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用, 格式类名.t

若云_bai的专栏 474

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

黑马程序员_JAVA笔记09—面向对象5(内部类、异常)

------- android培训、java培训、期待与您交流! ---------- 1、内部类         访问规则:                 内部类可以直接访问外部类中的成员,包括私有,之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式:外部类名.this                 外部类要访问内部类,必须建立内部类对象。

u011453546的专栏 673

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Java 09 异常

如果要自定义一个编译时异常类型,就自定义一个类,并继承 Exception如果要自定义一个运行时异常类型,就自定义一个类,并继承RuntimeException定义异常类写继承关系提供空参构造提供带参构造。

m0_71296672的博客 1074

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Java笔记2 面向对象<5>内部类、静态内部类、内部类定义原则、匿名内部类、异常概述、RuntimeException

09天-01-面向对象(内部类访问规则) Tip:内部类 l  将一个类定义在另一个类里面,对立面那个类就成为内部类(内置类,嵌套类)。 l  访问特点: 1)       内部类可以直接访问外部类中的成员,包括私有成员; 2)       而外部类要访问内部类中的成员,必须要建立内部类的对象。 class Outer{   private int x = 3;     c

l_215851356的专栏 757

Java09 异常

(1)定义规范:一个常见的做法是自定义一个BaseException作为“根异常”,然后,各种业务类型的异常即可继承自BaseException。BaseException需要继承自一个适合的Exception,通常建议继承自RuntimeException:(2)在BaseException中应提供多个构造方法:这样在抛出异常时即可选择不同的构造方法。super();

Stringzhua的博客 962

【09】面对对象5_内部类,匿名内部类,异常的处理

4.10内部类 4.10.1内部类的访问规则: 1.内部类可以直接访问外部类中的成员,包括私有。                   之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式外部类名.this 2.外部类要访问内部类,必须建立内部类对象。   练习一:内部类变量访问   class Outer { private int x =

努力后才会有收获....加油! 1349

java Day9异常

111

weixin_44102380的博客 173

day09内部类 异常

内部类:当描述事物时,事物的内部类还有事务,该事物用内部类来描述。 内部类的访问规则:1,内部类可以直接访问外部类中的成员,包括私有,。 之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this2,外部类要访问内部类,必须建立内部类对象。访问格式:1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中,可以直接建立内部类对象。格式: ...

weixin_30872499的博客 87

day09内部类,内部类的访问规则。匿名内部类,异常,自定义异常,RuntimeException

/* 内部类,内部类的访问规则。匿名内部类,异常,自定义异常,RuntimeException */ 内部类: class Outer { int x = 3; class Inner//内部类 { int x = 4; void function() { int x = 6; System.out.println

白骨书生的专栏 783

JAVA【09】 异常

一、java异常体系 1、Throwable接口 java.lang.Throwable:类是 Java 语言中所有错误或异常的超类。 Exception:编译期异常,进行编译(写代码)java程序出现的问题 1、RuntimeException: 运行期异常,java程序运行过程中出现的问题 异常就相当于程序得了一个小毛病(感冒,发烧),把异常处理掉, 程序可以继续执行(吃点药,继续革命工作) 2、非Runt

qq_1595986877 361

09 Java 异常处理

继承Exception(受检异常)或(非受检异常);提供无参构造和带错误信息的构造方法(方便传递异常原因)。// 自定义受检异常(继承Exception)// 无参构造// 带错误信息的构造方法// 调用父类构造,传递错误信息// 自定义非受检异常(继承RuntimeException)// 注册用户:年龄必须在18-60岁之间(受检异常,需throws声明)// 手动抛出自定义异常。

weixin_42847133的博客 651

09. Java 异常

有些公司为了提高代码的可重用性,自己开发了一些 Java 类库或框架,其中少不了自己编写了一些异常类。实现自定义异常类需要继承 Exception 类或其子类,如果自定义运行时异常类需继承 RuntimeException 类或其子类。我们通过继承 Exception 或者 RuntimeException 来定义一个异常。super();} }super();和很多其他异常类一样,我们没有定义额外的属性和代码,只是继承了Exception,定义了构造方法并调用了父类的构造方法。

acc8226的专栏 551

Java_09【异常】

异常顾名思义程序发生了和正常结果不同的的情况在Java编程思想中这样描述:是指阻止当前方法和作用与继续执行的问题。异常情形不等于普通问题。 01异常处理机制 当Java程序发生异常会有异常处理机制结关程序,并寻找一个恰当的地方来继续执行程序,这个恰当的地方就是异常处理程序,他的任务是将程序从错误中恢复,让程从错误中恢复,使程序要么换一种方式运行,要么继续下去。 02Java异常的种类 1。Jav...

java_Maxhui 217
上一篇: java多态--08
下一篇: java异常,包--10
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值