Java基础

Java基础

前篇

1. JRE、JDK

1. Java中内存分配

虚拟机自动调用main方法，进入栈中运行

变量与方法

1. 面试题

1.1 成员变量与局部变量的区别有哪些

a. 概念

b. 作用域

c. 存储位置

d. 生命周期

e. 初始值

f. 使用原则：

1.2 在Java中定义一个不做事且没有参数的构造方法的作用

java在执行子类的构造方法之前，若没有指定super(…)，则会默认调用父类的无参构造方法，若此时父类中只有有参构造方法，则编译时会发生错误。

1.3 在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？

帮助子类做初始化工作

1.4 一个类的构造方法的作用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为什么？

new一个对象的时候需要调用该类的构造方法，系统默认会创造一个不带参数的构造方法
官方：
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。

1.5 构造方法有哪些特性？

1.6 静态变量和实例变量区别

静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，它当且仅当在类初次加载时会被初始化，JVM只为静态变量分配一次内存空间。

实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在创建对象的时候被初始化，在内存中，创建几次对象，就有几份成员变量。

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

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

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

1.10值传递和引用传递有什么区别

1.11 对象相等判断之==和equals的区别？

1.12 hashCode 与 equals

2. 构造方法

2.1. 概述

若想都用，则两个构造方法都手动创建。直接给对象赋值了，姓名和年龄

2.2. 注意事项：

2.3. 方法重载

2.3.1. 概述

2.3.2. 好处

2.3.3. 面试题之方法重写与重载

3.1 构造器（constructor）是否可被重写（override）？
构造器不能被继承，因此不能被重写，但可以被重载。

3.2 重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

面向过程和面向对象(封装、继承、多态)

1. 概念

2.封装

2.1 解释

2.2 面试

3. 继承

《就近原则》

重要：子类中所有的构造方法默认都会先调用父类的无参构造方法！！！

super关键字

3.1. 继承中访问构造方法和成员变量的特点

3.2. 继承中成员方法访问特点：

3.3. super内存图

3.4. 方法重写

3.5.java中继承的注意事项

3.6. 案例

package com.weichen.test;
public class Test_fu_zi {
   
	public static void main(String[] args) {
   
		// TODO Auto-generated method stub
		Dog dog=new Dog("狗",22);
		dog.method();
		System.out.println(dog.getName()+dog.getAge());
		
		Cat cat=new Cat("猫",22);
		cat.method();
		System.out.println(cat.getName()+cat.getAge());
	}
}
class Animal{
   
	private String name;
	private int age;
	public Animal() {
   	
	}
	public Animal(String name,int age) {
   
		this.name=name;
		this.age=age;
	}
	public void setName(String name) {
   
		this.name=name;
	}
	public void setAge(int age) {
   
		this.age=age;
	}
	public String getName() {
   
		return name;
	}
	public int getAge() {
   
		return age;
	}
}
class Dog extends Animal{
   
	public Dog() {
   
		
	}
	public Dog(String name,int age) {
   
		super(name, age);
	}
	public void method() {
   
		System.out.println("我是狗，我可以看门");
	}
	
}
class Cat extends Animal{
   
	public Cat() {
   
		
	}
	public Cat(String name,int age) {
   
		super(name, age);
	}
	public void method() {
   
		System.out.println("我是猫，我可以抓老鼠");
	}
	
}

3.7. 面试之继承

3.8. 面试之super关键字的使用

4. 多态

4.1 概述

4.2 多态转型内存图解

数组：

1. 基本使用：

package com.weichen.test;

import java.util.Arrays;

public class Array_usually {
   

	public static void main(String[] args) {
   
		// TODO Auto-generated method stub
		//声明一个数组并分配空间：必须指定数组大小
		int[] arr1=new int[2];
		int[] arr2= {
   1,2,3,4};
		int[] arr3=new int[] {
   1,2,3,4};
		
		
		//数组的遍历方式1：
		for(int score:arr1) {
   
			System.out.println(score);
		}
		
		//数组的遍历方式2
		for(int i=0;i<arr2.length;i++) {
   
			System.out.println(arr2[i]);
		}
		
		
		//Arrays数组工具类的使用
		//1. 比较两个数组是否相等
		System.out.println("比较两个数组是否相等:"+Arrays.equals(arr2, arr3));  
		
		
		//2. 对数组的元素进行升序排列
		Arrays.sort(arr3); 
		System.out.println("对数组的元素进行升序排列:");
		for(int score:arr3) {
   
			System.out.println(score);
		}
		
		//3.将一个数组转换成一个字符串
		System.out.println("将一个数组转换成一个字符串"+Arrays.toString(arr2));
		
		//4.把数组array所有元素都赋值为val
		System.out.println("把数组array所有元素都赋值为val");
		Arrays.fill(arr1, 7);
		for(int score:arr1) {
   
			System.out.println(score);
		}
		
		//5.把数组复制成一个长度为length的新数组，返回类型与复制的数组一致
		int[] new_Array =Arrays.copyOf(arr1, 5);
		System.out.println("把数组复制成一个长度为length的新数组，返回类型与复制的数组一致");
		for(int score:new_Array) {
   
			System.out.println(score);
		}
		
		
		//6.查询元素值val在数组array中的下标(要求数组中元素已经按照升序排列)
		System.out.println("查询元素值7在数组arr1中的下标(要求数组中元素已经按照升序排列)");
		System.out.println(Arrays.binarySearch(arr1, 7));
		
	}

}

2、二维数组

3. LeetCode

import java.util.Arrays;
public class leetcode_01 {
   
	public static void main(String[] args) {
   
		// TODO Auto-generated method stub
		int[] heights= {
   1,1,4,2,1,3};
		int count=heightChecker(heights);
		System.out.println(count);

	}

	    public static int heightChecker(int[] heights) {
   
	    	int[] new_heights=heights.clone();
	    	int count=0;
	    	Arrays.sort(new_heights);

	            for(int i=0;i<heights.length;i++){
   
	                if(new_heights[i]==heights[i]){
   
	                    count++;
	                }
	            }
	            return count;
	    }
}

package com.weichen.test;
public class Leetcode_arr02 {
   

	public static void main(String[] args) {
   
		// TODO Auto-generated method stub
		int[] arr= {
   1,1,1,1,1};
		Solution solution=new Solution();
		int result=solution.numOfSubarrays(arr,1,0);
		System.out.println(result);
	}
}
class Solution {
   
    public int numOfSubarrays(int[] arr, int k, int threshold) {
   
    	int count=0;    //记录满足条件的数组个数	 
    	
    	//找出子数组
    	int[] sub_arr=new int[k]; 	
    	for(int i=0;i<arr.length-k+1;i++) {
     		   		
    		int temp=i;
    		for(int j=0;j<k;j++) {
   
    			sub_arr[j]=arr[temp++];
    		}
    		if(avg(sub_arr)>=threshold) {
   
    		    count++;
        	}
    	}		
    	return count;
    }

    //求平均值
    public int avg(int[] arr) {
   
    	int sum=0;
    	for(int i=0;i<arr.length;i++) {
   
    		sum+=arr[i];
    	} 	
		return sum/arr.length; 	
    }
}

package com.weichen.test;

import java.util.HashSet;
import java.util.Set;

public class Leetcode_04 {
   

	public static void main(String[] args) {
   
		// TODO Auto-generated method stub
		Solution_1 solution=new Solution_1();
		int[] nums= {
   2,2,3,4,5};
		int result=solution.findRepeatNumber(nums);
		System.out.println(result);
	}

}
class Solution_1 {
   
    public int findRepeatNumber(int[] nums) {
   
    	Set<Integer> set=new HashSet<Integer>();
    	int repeat=-1;
    	for(int num:nums) {
   
    		if(!set.add(num)) {
   
    			repeat=num;
    			break;
    		}
    	}  	
    	return repeat;
    }
}

4、案例

数组反转

public class test_flower {
   
	public static void main(String[] args) {
   
		int[] arr=new int[] {
   19,28,37,