JAVA基础整理加面试

局部变量和成员变量的区别？

在类中的位置不同 
	成员变量：类中，方法外 
	局部变量：方法中或者方法声明上(形式参数)
作用范围不一样 
	成员变量：类中 
	局部变量：方法中
初始化值的不同 
	成员变量：有默认值 
	局部变量：没有默认值。
在内存中的位置不同 
	成员变量：堆内存 
	局部变量：栈内存
生命周期不同 
	成员变量：随着对象的创建而存在，随着对象的消失而消失 
	局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

统计字符

• 字符数组：{‘a’,‘l’,‘f’,‘m’,‘f’,‘o’,‘b’,‘b’,‘s’,‘n’}

• 定义printCount方法，统计每个字符出现的次数并打印到控制台。

• 代码实现，部分效果如图所示：

• 开发提示：

  • 将数字强制转换，根据ASCII码表转换为字符。
  • 可以定义长度26的数组，每个元素，对应去保存每种字符的出现次数，比如0索引保存a的次数，1索引保存b的次数，以此类推。

• 参考答案：
  

public class MapTest {
public static void main(String[] args) {
        //友情提示
        System.out.println("请录入一个字符串:");
        String line = new Scanner(System.in).nextLine();
        // 定义 每个字符出现次数的方法
        findChar(line);
    }
    private static void findChar(String line) {
        //1:创建一个集合 存储  字符 以及其出现的次数
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        //2:遍历字符串
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            //判断 该字符 是否在键集中
            if (!map.containsKey(c)) {//说明这个字符没有出现过
                //那就是第一次
                map.put(c, 1);
            } else {
                //先获取之前的次数
                Integer count = map.get(c);
                //count++;
                //再次存入  更新
                map.put(c, ++count);
            }
        }
        System.out.println(map);
    }
}

定义sym方法，判断数组中的元素值是否对称.

代码实现，效果如图所示：

• 开发提示：
  • 数组中元素首尾比较。
• 参考答案：

 public class Test6 {
      public static void main(String[] args) {
          int[] arr = {1,2,3,4,3,2,1};
          System.out.println(Arrays.toString(arr) +" 是否对称:" +sym(arr) );

          int[] arr2 = {1,2,3,4,5,2,1};
          System.out.println(Arrays.toString(arr2) +" 是否对称:" +sym(arr2) );
      }

      public static boolean sym(int[] arr) {
          /*
          start : 数组头
          end :数组尾 
           */
          for (int start = 0 , end = arr.length -1 ; start <= end; start++, end--) {
              // 如果两端一旦有元素不等,就返回false
              if (arr[start] != arr[end]) {     
                  return false;
              }
          }
          return true;
      }
  }

定义equals方法，比较数组内容是否完全一致。

代码实现，效果如图所示：

• 开发提示：
  • 长度一致，内容一致，定义为完全一致。
• 参考答案：

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

          int[] arr = {1,2,3,4,3,2,1};
          int[] arr2 = {1,2,3,4,3,2,1};
          System.out.println(" 是否一致:" +equals(arr ,arr2) );

      }
      //  比较数组的内容
      public static boolean equals(int[] arr1, int[] arr2) {
  	// 长度不同,返回false
          if (arr1.length != arr2.length) {
              return false;
          }
  	
  	//
          for (int i = 0; i < arr1.length; i++) {
              // arr1[i] 和 arr2[i]比较
              /*
               * 所有元素都相同才相同，也就是只要有一个不同，这两个数组就是不同
               */
              if (arr1[i] != arr2[i]) {
                  return false;
              }
          }
          return true;
      }
  }

- 反转键盘录入的字符串。

代码实现，效果如图所示：

• 开发提示：
  • 使用字符数组保存原始字符，利用Random类生成随机索引。
• 参考答案：

public class Test1 {
		    public static void main(String[] args) {
		        Scanner scanner = new Scanner(System.in);
		        String next = scanner.next();
		        System.out.println("录入的字符串:" + next);
		        String s = reverseStr(next);
		        System.out.println("反转的字符串:"+ s);
		    }
		
		    public static String reverseStr(String  str){
		    //方法一
		        String s = "";
		        char[] chars = str.toCharArray();
		        for (int i = chars.length - 1; i >= 0; i--) {
		            s +=chars[i] ;
		        }
		        return s;
			
			//方法二
				//return new StringBuffer(str).reverse().toString();
				
			//方法三
		       //StringBuffer sb=new StringBuffer();
		        //int len=str.length();
		        //for(int i=len-1;i>=0;i--){
		            //sb.append(iniString.charAt(i));
		        //}
		        //return sb.toString();
		    }
		}

继承

1. 继承后，父类与子类之间，各成员有什么样的影响？
   • 成员变量：
     • 不重名，没有影响。
     • 重名，就近使用，使用super区分父类变量。
   • 构造方法：
     • 无影响，但是子类构造方法默认调用父类构造方法
   • 成员方法：
     • 不重名，没有影响。
     • 重名，子类重写父类方法。
2. 子类中，如何调用父类的成员？如何使用本类的成员？
   • 父类成员方法：super.方法名
   • 父类非私有成员变量：super.变量名
   • 子类成员方法：this.方法名
   • 子类成员变量：this.变量名
3. 抽象方法与普通成员方法有什么区别？
   • 抽象方法使用abstract关键字修饰，没有方法体。
   • 成员方法有方法体。
4. 抽象类与普通类有什么区别？
   • 方法：
     • 抽象类可以包含抽象方法和成员方法。
     • 普通类不可以包含抽象方法，只有成员方法。
   • 对象：
     • 抽象类不可以创建对象。
     • 普通类可以创建对象。

子类继承父类不重写

public class Test2 {
    public int x =10;
    public  void getA(){
        System.out.println(x);
    }    
    public static void main(String[] args) {
    	B b = new B();
        b.getB();
        b.getA();
    }

		}

class B extends Test2{
    public int x =100;
    public void getB(){
        System.out.println(x);
    }
}

输出：100
10

静态属性和静态方法不能重写

public class Test2 {
		    public static void main(String[] args) {
		        // 创建C对象
		       A c = new B();
		        // 调用c 中方法
		        c.showA();
		        System.out.println(c.numa);
		     
		    }
		}
		
		  class A{
			static int numa = 10;
		    public  static void showA() {
		    	System.out.println("A类中numa:"+numa);
		    };
		}
		
		class B extends A{
			static int numa = 20;
		    public  static void showA() {
		        System.out.println("A类中numa:"+numa);
		    }  
		}
		
		

输出：A类中numa:20
10

非静态方法调用任何（静态属性和静态方法不能重写）

public class Test2 {
		    public static void main(String[] args) {
		        // 创建C对象
		       A c = new B();
		        // 调用c 中方法
		        c.showA();
		        System.out.println(c.numa);
		     
		     
		    }
		}
		
		  class A{
			int numa = 10;
		    public  void showA() {
		    	System.out.println("A类中numa:"+numa);
		    };
		}
		
		class B extends A{
			int numa = 20;
		    public  void showA() {
		        System.out.println("A类中numa:"+numa);
		    }  
		}
		
		

输出：A类中numa:20
10

总结：子类有重写方法则调子类，子类没重写方法则用父类的，静态方法和属性和静态属性都不能重写，直接调用父类的

Set<Map.Entry<Car, Integer>> entrySet = hm.entrySet();
for (Map.Entry<Car, Integer> entry : entrySet) {
            Car key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key.getName() + ","+ key.getPrice() + " - "+ value);
        }