public class  Test
{
        public static void  main(String args[])
        {
                Test t  = new  Test();
                int  b  =  t.get();
                System.out.println(b);
        }
       
        public int  get()
        {
                try
                {
                        return 1 ;
                }
                finally
                {
                        return 2 ;
                }
        }
}
结果是2
public  class Test {

        public static void main(String[] args) {
                System.out.println(new Test().test());;
        }

        static int test()
        {
                int x = 1;
                try
                {
                        return x;
                }
                finally
                {
                        ++x;
                }
        }
       
}

结果
1

为什么这两个程序矛盾而都又对呢？
老师说try中的return语句调用的函数会先于finally中调用的函数执行，
请大家帮忙解决一下！！

我发表一下个人观点：第二个例子其实好理解在try中返回x，它的值是1.
关键是第一个，finally只有一种情况执行不到就是在try或者catch中有System.exit(参数)这种情况，你的try中返回一个1，主函数变量接收到1，但是函数没有结束还需要执行finally中内容又返回2，把主函数接收的变量更改了，所以最后接收的是个2而不是1
希望对楼主有帮助
其实你用IDE工具的Debug工具断点调试一下应该也知道工作流程

    Lz，以下是我修改的，你的第二个代码，就加了一个return语句。


    public  class Test {

            public static void main(String[] args) {
                    System.out.println(new Test().test());;
            }

            static int test()
            {
                    int x = 1;
                    try
                    {
                            return x;
                    }
                    finally
                    {
                            ++x;
                            return x;//这是我添加的代码
                    }
            }

打印结果：2

所以我觉得：执行流程应该是这样的：
test()中的try----->test()中的finally------->main()

你的第二个例子中finally语句是执行到了（没有return语句），但你定义的x是局部变量，只在test（）里有效，所以main（）只接收到了1，所以打印1

希望能帮到你。

说说自己的理解吧,我觉得是这样的,
在例一里,当执行到try里的return语句时,它会告诉虚拟机,"我要返回了,返回值1",但是得先执行finally语句块,
试想一下,如果结果是返回1,那就说finally里的语句根本没执行,这显然是不对的.于是执行finally里的return 2,这句一执行,就直接over了,返回2,
程序也不会再去返回1,因为已经over 了嘛

例二,同理,执行try里的return x,它会告诉虚拟机,"我要返回了,返回值1(这里的x是1)",接着执行finally里的++x,把x变成了2,finally语句块结束,
接着,前面的"我要返回了,返回值1"就执行了,程序结束

楼上正解~~

呵呵，惭愧，这个我之前也问过……给个参考：
try
{
//执行的代码，其中可能有异常。一旦发现异常，则立即跳到catch执行。否则不会执行catch里面的内容
}
catch
{
//除非try里面执行代码发生了异常，否则这里的代码不会执行
}
finally
{
//不管什么情况都会执行，包括try catch 里面用了return ,可以理解为只要执行了try或者catch，就一定会执行 finally
}

关键还是理解return语句。

而且，楼主，try,catch语句必须成对出现（尽管不出现异常时不会执行catch语句），finally语句可以不出现。

楼主 你第一个程序  就是限制性的try 后执行的finally
                 int  b  =  t.get();     //执行完try之后b=1，执行完finally之后return了2所以b=2
                System.out.println(b);
而你的第二个程序
           int x = 1;
                try
                {
                        return x;  //这里返回了1 这时b=1
                }
                finally
                {
                        ++x;   // 这时你并没有返回值 所以x虽然加了1变成了2 但是你没有返回值 所以这时b还是等于1
                }

public class  Test
{
        public static void  main(String args[])
        {
                Test t  = new  Test();
                int  b  =  t.get();
                System.out.println(b);
        }
        
        public int  get()
        {
                try
                {
                        return 1 ;
                }
                finally
                {
                        return 2 ;
                }
        }
}

这个get()函数它返回了两个值，一个是1,一个是2,但为什么结果是2呢？因为就好比有一个罐子，先放入了1,再放入了2,当你取出的时候，因为1在罐子底子下，取不到只能取到上面的2，所以最后的值是2.
对于你的第二个问题就更好解释了，因为finally（）里没有返回值所以你懂的。

public class  Test
{
        public static void  main(String args[])
        {
                Test t  = new  Test();
                int  b  =  t.get();
                System.out.println(b);
        }
        
        public int  get()
        {
                try
                {
                        return 1 ;//程序执行到此b=1,由于程序未结束，所以继续执行
                }
                finally
                {
                        return 2 ;//程序执行到此b的值被返回的2替换，最终得到的b=2
                }
        }
}

public  class Test {

        public static void main(String[] args) {
                System.out.println(new Test().test());;
        }

        static int test()
        {
                int x = 1;
                try
                {
                        return x;//程序执行到此返回x=1，并由主函数打印
                }
                finally
                {
                        ++x;//程序执行到此x自增，并没有返回，因此最终x=1
                }
        }
        
}

以上是我的理解，如有不足还请各位指正

在执行finally语句之前，jvm会将try或者catch中的局部变量入栈，防止在finally中被修改，也就是说你在finally中无论修改了什么，在try中的return都不会变，当然，除非你在finally中return，但是这样做编译器会给出警告信息。
也就是说try语句执行到return，此时将局部变量压栈，转而执行finally。