目录
一、面试题
类初始化和实例初始化问题
父类方法
/**
* @packageName: PACKAGE_NAME
* @user: wentao
* @date: 2022/10/11 15:58
* @email 1660420659@qq.com
* @description: 父类
*
* 父类初始化
* （1）静态类变量
* （2）父类的静态代码块
* 父类的实例化方法：
* （1）super() （最前）
* (2)父类非静态变量 中间两个按照顺序
* （3）父类非静态代码块
* （4）父类的无参构造方法 （最后）
*
*
* 非静态成员方法其实有一个默认的对象 this
* this在构造器 或者是<init>表示正在创建的对象
* 因为这里是在创建子类对象 所以test()执行的是子类的重写的代码 （面向对象）
* 因此这里test()执行的是子类重写的test()方法
*/
public class Facher {
private int i= test();
private static int j=method();
//静态代码块
static {
System.out.print("(1)");
}
//构造方法
Facher(){
System.out.print("(2)");
}
//非静态代码块
{
System.out.print("(3)");
}
public int test(){
System.out.print("(4)");
return 1;
}
public static int method(){
System.out.print("(5)");
return 1;
}
}
子类方法
/**
* @packageName: PACKAGE_NAME
* @user: wentao
* @date: 2022/10/11 16:01
* @email 1660420659@qq.com
* @description: 子类
*
* 初始化子类
* 先初始化父类 （5）（1）
* 子类初始化
* （1）静态类变量 （10）
* （2）子类的静态代码块 （6）
*
* 子类的实例化方法：
* （1）super() （最前） (9)(3)(2)
* (2)子类非静态变量 (9) 中间两个按照顺序
* （3）子类非静态代码块 (8)
* （4）子类的无参构造方法 （最后） (7)
*
* 因为创建了2个Son对象 因此我们实例初始化 <init>执行了2遍
* (9)(3)(2) (9)(8)(7) 有执行了一遍
*/
public class Son extends Facher {
private int i= test();
private static int j=method();
//静态代码块
static {
System.out.print("(6)");
}
//构造方法
Son(){
System.out.print("(7)");
}
//非静态代码块
{
System.out.print("(8)");
}
/**
* 重写父类的方法
*/
@Override
public int test(){
System.out.print("(9)");
return 1;
}
public static int method(){
System.out.print("(10)");
return 1;
}
public static void main(String[]args){
Son s1=new Son();
System.out.println();
Son s2=new Son();
}
}输出结果是
首先我们先复习一下要点
知识点
-
类初始化过程
-
一个类要创建实例需要先加载并初始化该类
-
main方法所在的类需要先加载和初始化
-
一个子类要初始化需要先初始化父类
-
一个类初始化就是执行<clinit>方法
-
<clinit>方法是由静态类变显示赋值代码和静态代码块组成的
-
并且静态类变量和静态代码块从上到下顺序执行的
-
<clinit>只执行一次
-
-
-
实例初始化过程
-
实例初始化就是执行<init>方法
-
<init>方法有非静态实例变量显示赋值代码和非静态代码块、对应的构造器代码组成
-
实例初始化最先执行的是super（）--即对应父类的<init>方法 构造方法总是最后执行
-
非静态实例变量显示赋值代码和非静态代码块是按照上下顺序来执行
-
每次创建实例对象，调用对应的构造器，执行的就是对应的<init>方法
-
-
方法的重写
-
那些方法不会被重写
-
final方法
-
静态方法
-
private等子类中不可见的方法
-
-
对象的多态性
-
子类如果重写了父类的方法，通过子类对象调用的一定是子类重写后的代码
-
非静态方法默认调用的对象是this
-
this对象在构造器或者说<init>方法中就是正在创建的对象
-
-
方法参数传递机制
import java.util.Arrays;
/**
* @packageName: PACKAGE_NAME
* @user: wentao
* @date: 2022/10/11 16:32
* @email 1660420659@qq.com
* @description: 方法的参数传递机制
*/
public class Exam {
public static void main(String[]args){
int i=1;
String str="hello";
Integer num=20;
int[] arr={1,2,3,4,5};
MyData myData=new MyData();
change(i,str,num,arr,myData);
System.out.println("i="+i);
System.out.println("str="+str);
System.out.println("num="+num);
System.out.println("arr="+Arrays.toString(arr));
System.out.println("myData="+myData.a);
}
public static void change(int j,String s,Integer n ,int []a ,MyData m){
j+=1;
s+="word";
n+=1;
a[0]+=1;
m.a+=1;
}
}
/**
* 类
*/
class MyData{
int a=18;
}
运行结果
要点
-
方法的参数传递机制
-
形参是基本数据类型 传递的是数据值
-
形参是引用数据类型 传递的是地址值
-
-
String、包装类等对象是不可变性的（特殊）
画图分析
二、算法
合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
示例 1： 输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]] 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. 示例 2： 输入：intervals = [[1,4],[4,5]] 输出：[[1,5]] 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
提示：
1 <= intervals.length <= 104 intervals[i].length == 2 0 <= starti <= endi <= 104
作者：力扣 (LeetCode) 链接：力扣 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
我的代码
class Solution {
public int[][] merge(int[][] intervals) {
//首先特殊情况 intervals为空的时候直接返回
if(intervals.length==0) return intervals;
//先将二维数组的列进行升序排列
Arrays.sort(intervals,(a,b)->a[0]-b[0]);
//然后声明一个临时数组存储，先将第一行加入到数组中
int [] term=intervals[0];
//声明一个集合存储合并后的数组
List<int[]> list=new ArrayList();
for(int i=1;i<intervals.length;i++){
//判断前一个的第二个是否大于下一个的第一个
if(term[1]>=intervals[i][0]){
//然后直接选择第二个数中最大的即可
term[1]=Math.max(term[1],intervals[i][1]);
}
else{
//不成立就将上一个合并成功的加入到集合中
list.add(term);
//然后将不成功的这个变成term 继续比较
term=intervals[i];
}
}
//最后比较完毕将最后的加入进去
list.add(term);
//最后将集合转换成要返回的数组
return list.toArray(new int[list.size()][2]);
}
}要点
Arrays.sort(intervals,(a,b)->a[0]-b[0]); a[0]-b[0] 是升序 Arrays.sort(intervals,(a,b)->a[0]-b[0]); b[0]-a[0] 是降序 主要是通过一个中间变量来存储这个数据 并且我们不知道要合并的数量导致个数是无法确定的，因此要使用集合 最后通过集合准换成二维数组进行输出。
旋转矩阵
给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。
不占用额外内存空间能否做到？
示例 1: 给定 matrix = [ [1,2,3], [4,5,6], [7,8,9] ], 原地旋转输入矩阵，使其变为: [ [7,4,1], [8,5,2], [9,6,3] ] 示例 2: 给定 matrix = [ [ 5, 1, 9,11], [ 2, 4, 8,10], [13, 3, 6, 7], [15,14,12,16] ], 原地旋转输入矩阵，使其变为: [ [15,13, 2, 5], [14, 3, 4, 1], [12, 6, 8, 9], [16, 7,10,11] ]
作者：力扣 (LeetCode) 链接：力扣 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
我的代码
class Solution {
public void rotate(int[][] matrix) {
//创建一个二维数组
int[] [] arr =new int [matrix.length][matrix[0].length];
//通过循环将二维数组旋转90度
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[0].length;j++){
arr[i][j]=matrix[matrix.length-j-1][i];
}
}
//改变后逐个赋值给matrix
for(int y=0; y<matrix.length; y++){
for(int x=0; x<matrix[0].length; x++){
matrix[x][y]=arr[x][y];
}
}
}
}
我的这个时间复杂度是O（n^2）
扫一扫
790
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
