java 数组 lambda_Java中内部类、Lambda表达式、数组的主要内容及作用

最新推荐文章于 2025-04-28 20:31:22 发布

申晨煜

最新推荐文章于 2025-04-28 20:31:22 发布

阅读量502

点赞数

文章标签： java 数组 lambda

本文链接：https://blog.youkuaiyun.com/weixin_35353583/article/details/114350827

版权

一、内部类

含义:类中定义类就是内部类

如果一个事物的成员也是一个事物,可以使用内部类来定义

分类:成员内部类、静态内部类、局部内部类、私有内部类、匿名内部类

1、成员内部类

内部类定义在外部类的成员位置

成员:可以使用成员修饰符,public static ...

类:可以继承类,可以实现接口；$内部类

内部类中可以直接使用外部类中的所有的内容,包括私有的

内部类中不可以直接定义静态的内容,除了静态的常量,静态的内容要定义在静态内部类当中

例子

public class Outer01{

public String name="张三丰";

private int age=18;

private static int height=180;

//成员内部类

public class Inner extends A implements B{

static final int A=5;

private int b=10;

public void haha(){

System.out.println(A);

System.out.println(name);

System.out.println(age);

System.out.println(height);

}

@Override

public void test() {

}

//外部类的成员方法

public void outer(){

Inner in=new Inner();

System.out.println(Inner.A);

System.out.println(in.A);

System.out.println(in.b);

in.haha();

}

class A{}

interface B{

void test();

}

2、静态内部类

1.静态内部类可以定义静态的内容可以定义成员的内容

2.在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用

3.在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态内部类中的成员内容

4.在其他类中可以通过外部类名.静态内部类名.静态内容使用静态内部类中的静态内容

new 外部类.静态内容类() 创建静态内部类的对象使用静态内部类中的成员

例子

public class StaticInner {

public static void main(String[] args) {

System.out.println(Outer04.Inner.id);

Outer04.Inner.hehe();

Outer04.Inner in=new Outer04.Inner();

in.haha();

}

class Outer04{

private int a=5;

private static int b=10;

//静态内部类

static class Inner{

//静态内部类中的静态变量

static int id=0;

//静态内部类中的成员变量

String name="三子峰";

//静态内部类中的静态方法

static void hehe(){

System.out.println(id);

Inner in=new Inner();

System.out.println(in.name);

System.out.println(b);

Outer04 s=new Outer04();

System.out.println(s.a);

}

//静态内部类中的成员方法

void haha(){

System.out.println(id);

System.out.println(name);

Outer04 s=new Outer04();

System.out.println(b);

System.out.println(s.a);

}

//外部类中的成员方法

void outer(){

System.out.println(Inner.id);

Inner in=new Inner();

System.out.println(in.name);

Inner.hehe();

in.haha();

}

3、局部内部类

方法中定义内部类

1.局部内部类不可以使用成员修饰符修饰(比如:public,static...不包括final)

2.只能在当前定义局部内部类的方法中可以通过内部类的对象使用内部类中的成员,通过类可以使用静态

3.局部内部类所再的方法的参数,在jdk1.8之后默认,1.7之前需要显示定义

例子

public class LocalInner {

public static void main(String[] args) {

}

//外部类

class Outer05{

String name="李四";

//成员方法

void test(final int args){

int a=5; //局部变量

//局部内部类

class Inner{

static final int age=18;

int height=185;

void inner(){

System.out.println(a);

System.out.println(age);

System.out.println(name);

System.out.println(args);

//args=15;

}

//在当前方法中使用局部内部类中的内容

System.out.println(Inner.age);

Inner in=new Inner();

in.inner();

System.out.println(in.height);

}

void outer(){

test(4);

/*Inner in=new Inner();

in.inner();*/

}

4、私有内部类

私有内部类中可以使用外部类中所有的内容,包括私有的

私有内部类只能在外部类中可以通过对象使用私有内部类中的私有内容,其他类中不能使用

例子

public class PrivateInner {

public static void main(String[] args) {

//new Outer03().new Inner().haha();

}

//外部类

class Outer03{

private int a=10;

private static int b=20;

//私有内部类

private class Inner{

private int c=30;

private void haha(){

System.out.println(c);

System.out.println(a);

System.out.println(b);

}

//外部类的成员方法

public void outer(){

Inner in=new Inner();

System.out.println(in.c);

in.haha();

}

5、匿名内部类

没有名字的内部类

简化没有独自作用|功能的实现|子类

例子

public class AnonymousInner {

public static void main(String[] args) {

//new Demo().smoke();

//1.用完销毁,不能使用第二次

//匿名内部类

/*new Smoking(){ //--匿名内部类的蕾体是new后面的接口或者父类的实现类|子类的类体

public void smoke() {

System.out.println("抽烟");

}

@Override

public void cat() {

System.out.println("玩猫");

}

}.cat();*/

//2.引用接收匿名内部类对象的地址---接口多态

Smoking s=new Smoking(){ //--匿名内部类的蕾体是new后面的接口或者父类的实现类|子类的类体

public void smoke() {

System.out.println("抽烟");

}

@Override

public void cat() {

System.out.println("玩猫");

}

};

s.smoke();

useUSB(new USB(){

@Override

public void start() {

System.out.println("开始使用移动硬盘");

}

@Override

public void end() {

System.out.println("结束使用移动硬盘");

}

);

useUSB(new USB(){

@Override

public void start() {

System.out.println("开始使用键盘");

}

@Override

public void end() {

System.out.println("结束使用键盘");

}

);

}

static void useUSB(USB usb){

usb.start();

usb.end();

}

interface USB{

void start();

void end();

}

interface Smoking{

void smoke();

void cat();

}

二、Lambda表达式

目标:简化匿名内部类

语法: ()->{}

() :-->重写的抽象方法的参数列表

-> :箭头符号,箭头函数,Lambda符号

{} :重写的抽象方法的方法体

前提:函数式接口

函数式接口:只有一个抽象方法的接口就是函数式接口

@FunctionalInterface : 强制检查是否为函数式接口

例子

public class LambdaDemo {

public static void main(String[] args) {

/*Code c=new Code(){

@Override

public void code(int haha) {

System.out.println("边敲代码边哄女朋友");

}

};*/

//Lambda表达式写法1

/*Code c=()->{

System.out.println("边敲代码边哄女朋友");

};*/

//写法2:如果方法的语句体只有1句,前后的{}可以省略

//Code c=()->System.out.println("边敲代码边哄女朋友");

//写法3: 如果存在参数,参数的数据类型可以省略

//Code c=(i,m)->System.out.println("边敲代码边哄女朋友"+i+"次");

//写法4:如果存在参数,并且参数只有一个前后的()可以省略

/*Code c= i ->{

System.out.println("边敲代码边哄女朋友"+i+"次");

return -1;

};

System.out.println(c.code(100));*/

//写法5: 有返回值类型的方法,如果方法体语句只有1句,并且是return语句的时候,这时前后{},包括return都可以省略

Code c= str -> str.length();

System.out.println(c.code("因为"));

}

//函数式接口

@FunctionalInterface

interface Code{

//void code();

int code(String a);

}

三、数组

数组: []

相同数据类型的有序集合

变量: 存储单个数据

数组: 存储多个数据

数组的特点:

1.数组是引用数据类型

2.数组是定长的,长度一旦确定不可改变

3.数组中所有数据的数据类型保持一致

4.数组中的数据存在顺序(索引:从0开始)

数组的声明方式:

1) 数据类型[] 数组名;

数据类型:可以是基本数据类型|引用数据类型

数据类型的作用:规定数组中所有数据的数据类型

2) 数据类型数组名[]; --不推荐使用

数组的初始化:

动态初始化:先创建后赋值

数据类型[] 数组名 = new 数据类型[长度];

数组中的数据如果不赋值有默认值 String--null,int--0,double--0.0 ,char--' ',boolean--false

静态初始化:创建的同时赋值

数据类型[] 数组名 =new 数据类型[]{值1,值2,值3...};

数据类型[] 数组名 ={值1,值2,值3...}; --推荐

操作(获取|修改)数组中的数据

通过索引操作数组名[索引|下标]

数组的长度:

数组名.length

数组中最后一个数据的下标:

数组名.length-1

数组的遍历:

1)普通for循环,可以获取可以修改,因为是操作索引(位置)

2)增强for循环|for..each ,只能获取每一个数据,不能修改

for(数据类型变量名: 数组名|容器名){

变量-->指代数组中的每一个数据

}

例子

public class ArrayDemo {

public static void main(String args[]) {

//声明一个int类型的数组

int[] arr;

Person[] arr2;

//动态初始化

//真实创建一个长度为4的存放int类型数据的数组名字为arr

arr=new int[4];

//获取数组的数据

System.out.println(arr[2]);

//数组中赋值

arr[0]=6;

arr[1]=7;

arr[2]=8;

arr[3]=9;

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[3]);

静态初始化1

String[] arr3=new String[]{"你","好"};

System.out.println(arr3[0]);

System.out.println(arr3[1]);

静态初始化2

char[] arr4={'s','h','s','x','t'};

System.out.println(arr4[0]);

System.out.println(arr4[1]);

System.out.println(arr4[2]);

System.out.println(arr4[3]);

System.out.println(arr4[4])；

长度

System.out.println("长度"+arr4.length);

System.out.println("最后一个数据"+arr4[arr4.length-1]);

System.out.println("----------普通for-------------");

遍历数组1)普通for

i做数组的索引规律:每次+1 范围:0~length-1

for(int i=0;i<=arr4.length-1;i++){

System.out.println(arr4[i]);

}

动态为arr数组赋值

for(int i=0;i<=arr.length;i++){

arr[i]=101+i;

}

遍历

for(int i=0;i

System.out.println(arr[i]);

}

System.out.println(arr); /[I@15db9742

遍历数组1)增强for

for(char i :arr4){

System.out.println(i);

}

class Person{}

1、使用数组时常见的异常

1.NullPointerException 空指针异常

对象指向为null,根据这个对象做一些操作,可能对出现空指针

2.ArrayIndexOutOfBoundsException 数组索引越界异常

索引为负数

索引超出最大范围

例子

public class ArrayException {

public static void main(String[] args) {

int[] arr=new int[3];

arr=null;

System.out.println(arr[1]);

boolean[] arr2={false,true,false};

System.out.println(arr2[5]);

}

2、可变参数

可变参数:数据类型相同的0~多个参数

1.使用...表示可变参数

2.编译器会自动为可变参数隐式创建一个数组,通过操作数组的方式使用可变参数

3.可变参数必须放在参数列表的最后位置

代码例子

public class ParaDemo {

public static void main(String[] args) {

getSum(1,2,3,4,5,6);

test(1,"","",1,false);

}

至少接收一个参数,可以接收多个参数

public static void test(int name,Object ...arr){

System.out.println(name);

for(Object n:arr){

System.out.println(n);

}

计算int类型参数的和

public static void getSum(int ...i){

System.out.println("可变参数方法");

System.out.println(i);

int sum=0;

for(int n:i){

sum+=n;

}

System.out.println(sum);

}

public static int getSum(int x,int y){

System.out.println("可2个参数方法");

return x+y;

}

public static int getSum(int x,int y,int z){

System.out.println("可3个参数方法");

return x+y+z;

}