ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

每天面试12题（2）

2021-07-20 19:03:23  阅读：131  来源： 互联网

标签：12 内部 每天 int System 面试 new 静态 out


1.静态变量和实例变量区别

静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。
实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

2.静态变量与普通变量区别

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

3.静态方法和实例方法有何不同？

静态方法和实例方法的区别主要体现在两个方面：

在外部调用静态方法时，可以使用"类名.方名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制

4.在一个静态方法内调用一个非静态成员为什么是非法的？

由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。

5.什么是方法的返回值？返回值的作用是什么？

方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！

6.什么是内部类？

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。

7.内部类的分类有哪些

内部类可以分为四种：

成员内部类、局部内部类、匿名内部类和静态内部类。

静态内部类
定义在类内部的静态类，就是静态内部类。

public class Outer {

    private static int radius = 1;

    static class StaticInner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
        }
    }
}

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建方式，new 外部类.静态内部类()，如下：

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();

成员内部类
定义在类内部，成员位置上的非静态类，就是成员内部类。

public class Outer {

    private static  int radius = 1;
    private int count =2;
    
     class Inner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
            System.out.println("visit outer   variable:" + count);
        }
    }
}

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式外部类实例.new 内部类()，如下：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();

局部内部类
定义在方法中的内部类，就是局部内部类。

public class Outer {

    private  int out_a = 1;
    private static int STATIC_b = 2;

    public void testFunctionClass(){
        int inner_c =3;
        class Inner {
            private void fun(){
                System.out.println(out_a);
                System.out.println(STATIC_b);
                System.out.println(inner_c);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
    public static void testStaticFunctionClass(){
        int d =3;
        class Inner {
            private void fun(){
                // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
                System.out.println(STATIC_b);
                System.out.println(d);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
}

定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式，在对应方法内，new 内部类()，如下：

 public static void testStaticFunctionClass(){
    class Inner {
    }
    Inner  inner = new Inner();
 }

匿名内部类

匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

public class Outer {

    private void test(final int i) {
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类" );
                }
            }
        }.method();
    }
 }
 //匿名内部类必须继承或实现一个已有的接口 
 interface Service{
    void method();
}

除了没有名字，匿名内部类还有以下特点：

匿名内部类必须继承一个抽象类或者实现一个接口。
匿名内部类不能定义任何静态成员和静态方法。
当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
匿名内部类创建方式：

new 类/接口{ 
  //匿名内部类实现部分
}

8.内部类的优点

我们为什么要使用内部类呢？因为它有以下优点：
● 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
● 内部类不为同一包的其他类所见，具有很好的封装性；
● 内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
● 匿名内部类可以很方便的定义回调。

9.内部类有哪些应用场景

  1. 一些多算法场合
  2. 解决一些非面向对象的语句块。
  3. 适当使用内部类，使得代码更加灵活和富有扩展性。
  4. 当某个类除了它的外部类，不再被其他的类使用时。

10.局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？

因为不能对内部类进行修改

11.有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，把原有的数据和计算出的平均分数存放在磁盘文件 "stud "中。

package test2;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;

class Student {
	String num;
	String name;
	double[] score;
	double agv;

	Student() {
		num = null;
		name = null;
		score = new double[3];
		for (int i = 0; i < 3; i++) {
			score[i] = 0;
		}
	}

	Student(String num, String name, double s1, double s2, double s3) {//本题目没有要求
		this.num = num;
		this.name = null;
		score = new double[3];
		score[0] = s1;
		score[1] = s2;
		score[2] = s3;
	}

	double agv(double[] n) {
		double v = 0;
		for (int i = 0; i < n.length; i++) {
			v += n[i];
		}
		return v / n.length;
	}
}

public class test50 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Student[] student = new Student[5];
		;
		for (int i = 0; i < 5; i++) {
			student[i] = new Student();
		}
		Scanner sc = new Scanner(System.in);
		BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
		for (int i = 0; i < 5; i++) {
			System.out.println("请输入第" + (i + 1) + "位同学的成绩");
			student[i].num = sc.next();
			student[i].name = sc.next();
			student[i].score[0] = sc.nextDouble();
			student[i].score[1] = sc.nextDouble();
			student[i].score[2] = sc.nextDouble();
			student[i].agv = (student[i].score[0] + student[i].score[1] + student[i].score[2]) / 3;
		}
		try {
			BufferedWriter w = new BufferedWriter(
					new OutputStreamWriter(new FileOutputStream("C:\\360Downloads\\stud")));
			for (int i = 0; i <5; i++) {
				w.write(student[i].num);
				w.write(student[i].name);
				w.write(String.valueOf(student[i].score[0]));//将double类型的分数转换为String类型写入
				w.write(String.valueOf(student[i].score[1]));//因为write方法不能写入double类型的数值
				w.write(String.valueOf(student[i].score[2]));
			}
			w.flush();
			w.close();
			System.out.println("ture");//成功保存输出ture
		} catch (Exception e) {
			System.out.println(e.toString());
		}
	}

}

12.某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

public class work2 {
    public static int shuru() {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入四位整数:");
        int su = s.nextInt();
        return su;
    }
    public static void suan(int i) {
        int a = i / 1000;
        int b = i / 100 % 10;
        int c = i / 10 % 10;
        int d = i % 10;
        a += 5;
        b += 5;
        c += 5;
        d += 5;
        a = a % 10;
        b = b % 10;
        c = c % 10;
        d = d % 10;
        System.out.println(d +""+ c +""+ b +""+ a);
    }
    public static void main(String[] args) {
        int i = shuru();
        suan(i);
    }
}

标签：12,内部,每天,int,System,面试,new,静态,out
来源： https://blog.csdn.net/qq_46344415/article/details/118942182

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有