java基础笔记（4）内部类，静态内部类，局部内部类，匿名内部类，异常

最新推荐文章于 2022-04-26 14:13:12 发布
最新推荐文章于 2022-04-26 14:13:12 发布
阅读量360 收藏
点赞数
文章标签： java exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/echoxxxxx/article/details/112442375
版权

1.内部类
成员内部类
1.可以使用四种访问权限修饰符修饰的
2. 局部变量是不能用static修饰的
3. 内部类字节码文件命名方式 外部类$内部类.class
4. 内部类是可以使用外部类的属性和方法的，包括私有的
5. 外部类属性和内部类属性同名的时候优先使用内部类的
6. 即使用this也是使用的内部类的,除非创建外部类对象调用
7. 使用内部类的时候必须要导包
8. 内部类创建方式 要通过 外部类对象创建内部类对象
里面包裹的类 : 内部类
外面的类: 外部类, 宿主类
四类:
成员内部类
静态内部类
局部内部类
匿名内部类

public class Car {
	String color = "绿色";
	private void run() {
		System.out.println("跑");	
	}
	public class 发动机{
		String color = "红色的";
		String type;		
		public void work() {
			System.out.println("发动机");
			run();
			System.out.println(new Car().color);
		}
	}
}
import demo.Car.发动机;
public class Test {
	public static void main(String[] args) {
		Car car = new Car();
		car.color = "绿色";		
		发动机 f = car.new 发动机();
		发动机 f2 = new Car().new 发动机();
		f2.type = "345";
		f2.work();
	}
	class Test2{
		public void a() {			
		}
	}
}

2.静态内部类
1.静态内部类中可以使用静态的属性和方法
2.字节码文件的名字 外部类$内部类.class
3.静态内部类中 不能直接使用外部类的非静态的属性和方法
4内部类中的属性和外部类属性同名的时候, 可以通过外部类.静态属性 调用外部类属性
5.静态内部类可以直接创建对象 不需要外部类对象

public class Outer {
	static String name;
	int age;	
	public void run() {
		System.out.println("跑");		
	}
	static class Inner{ 
		int a;
		static int b;
		static String name;
		public void a() {
			System.out.println("a");
			System.out.println(Outer.name);
		}
		public static void b() {
			System.out.println("static的b");
		}
	}
}
import demo2.Outer.Inner;
public class Test {
	public static void main(String[] args) {
		Inner inner = new Inner();		
	}
}

3.局部内部类
局部内部类 类似于一个局部变量
1.局部内部类定义在方法内部的类
2. 不能使用访问权限修饰符以及 static进行修饰
3. 局部内部类中可以使用 外部类的属性也可以使用方法中的局部变量
4. 如果局部内部类中的属性和外部类成员属性同名, 则可以使用外部类.this.属性 调用外部类的属性
5. 局部内部类只能在声明此内部类的方法中创建对象
6. 局部内部内部类只能方法被调用的时候,才能执行

public class Test {
	int a = 3;
	public static void main(String[] args) {
		Test test = new Test();
		test.test();
	}
	public void test() {
		int age = 3;
class Inner{
			public String name = "mingzi";
			private int a = 5;
			public void show() {
				System.out.println(name);
				System.out.println(age);
				System.out.println(Test.this.a);
			}
		}
		Inner inner = new Inner();
		inner.show();
	}
}

4.匿名内部类
1.没有自己本类的名字, 只能拿接口或者抽象类的名字代表
2.创建的是实现类或者子类的对象
左边是接口的名字 = 右边是实现类的对象 向上转型
3.不会再匿名内部类中新增 特有方法, 因为没有办法通过接口名字调用
3. 即使一个内部类或者接口 ,new了多次, 是多个实现类
4. 当有实现类或者子类只需要创建一次对象,则可以使用匿名内部类. 可以使程序结构更加简洁
5. 匿名内部类的名字 外部类$数字.class
匿名内部类中可以额外定义自己的方法, 但是一般不这样做

public class Test {
	public static void main(String[] args) {
		MyRunnable runnable = new MyRunnable();
		runnable.run();
		// 只想创建一个实现类的对象 , 调用一次run方法
				// 利用匿名内部类的写法
		Runnable runnable2 = new Runnable() {
			
			@Override
			public void run() {
				System.out.println("线程2");
			}
		};
		runnable2.run();
	}
}
class MyRunnable implements Runnable{
	@Override
	public void run() {
	System.out.println("线程");
	}
}

public abstract class AbstractClass {
	public abstract void b();
}
public class Animal implements Run{
	@Override
	public void run() {
	System.out.println("动物跑步");
	}
}
public class Person implements Run{
	@Override
	public void run() {
	System.out.println("人跑步");
	}
	public void eat() {		
	}
}
public interface Run {
	public void run();
}
public class Test3 {
	public static void main(String[] args) {
		Person person = new Person();
		person.run();		
		Animal animal = new Animal();
		animal.run();		
		Run run = new Run() {			
			@Override
			public void run() {
				System.out.println("外星人跑步");
				eat();
			}
			public void eat() {				
			}
		};
		run.run();		
		//创建抽象类对象
		AbstractClass class1 = new AbstractClass() {			
			@Override
			public void b() {
				System.out.println("bbb");
			}
		};
		class1.b();		
		AbstractClass class2  = new AbstractClass() {			
			@Override
			public void b() {
				System.out.println("bbb");
			}
		};
		class2.b();
	}
}

基本数据类型在参数传递的时候,传递的是 数值
引用数据类型在参数传递的时候,传递的是地址(引用)
值传递 和引用传递
注意:
String字符串作为参数的时候,传递的是 地址(引用),但是常量池存储数据的特点:
如果即将要存储的数据在常量池中存在,则直接使用, 如果不存在,则重新开辟新的空间存储, 绝对不会修改内容

public class Person {
	String name;
	int age;
}
public class Test2 {
	public static void main(String[] args) {
		Person p = new Person();
		p.name = "lisi";
		p.age = 15;		
		a(p);
		System.out.println("main-->"+p.name+" "+p.age);
	}
	public static void a(Person p) {
		p.name = "zhangsan";
		p.age = 5;
		System.out.println("a-->"+p.name+" "+p.age);
	}
}

5.异常
运行时异常
非运行时异常,编译时期就会报错,必须处理,不处理就无法运行 涉及到外界资源, 有可能会因为外界资源的改变导致 出现问题,无论是否发生异常都要求处理以后才能执行 , 在编译实际就会 提示
程序如果发生了异常
先执行try 代码块，发现异常,jvm自动的创建异常的对象 ，查找能够捕获异常的代码找catch，如果catch中的类型和异常类型匹配则执行catch块进行处理异常，程序继续向下执行,不会中断，如果catch中类型不匹配,则直接爆出异常, 让程序中断
如果没有发生异常:
先执行try块，如果没有异常则执行完try以后执行 不执行catch
finally无论是否发生异常 都会执行此代码
资源清理和关闭的操作,还有直接退出系统 才不执行 否则一定会执行 即使 return break也必须要执行
System.exit(0);不执行
throws 可以跟多个异常类型, 标明方法内部可能存在异常, 如果发生异常 将异常转给调用者,标明异常存在的可能性 抛出异常
throws 异常发生的可能性 , 声明异常 , 写在方法声明后面 , 跟的异常类型,可以跟多个，
throw产生异常，抛出异常 , 方法内部的, 跟的是异常对象, 只能跟一个，只要出现了throw 通常会结合throws 使用，throw 后面跟的是异常对象, 真正产生异常
如果想要自定义非运行时异常 继承Exception
只有继承了RuntimeException 才是运行时异常

  1. 异常体系中:
    Thrwable
    Error: 严重性错误, 没有办法直接解决, 只能尽量避免
    Exception : 异常,通常都是逻辑错误导致的 , 可以解决
  2. 异常的处理机制:
    当发生异常的时候,会产生异常对象, 去查找处理异常的代码, 如果找到则交由其处理, 程序正常运行
    没有找到则 程序终止
  3. 异常的分类:
    运行时异常(非受检异常)
    非运行时异常(受检异常,编译时异常)
  4. 处理异常的方式
    try
    catch
    finally
  5. throw 和throws
    throws 异常发生的可能性 , 声明异常 , 写在方法声明后面 , 跟的异常类型,可以跟多个
    throw new NullPointerException();// 产生异常 抛出异常 , 方法内部的, 跟的是异常对象, 只能跟一个
    只要出现了throw 通常会结合throws 使用
  6. 自定义异常: 针对于业务逻辑可能会要求写一些 异常,
    自定异常:
    继承RuntimeException 运行时异常,
    继承Exception 非运行时异常. 非运行时异常通常都是与外界资源有联系
public class LegException extends Exception{
	public LegException() {
		super();
	}
	public LegException(String message) {
		super(message);
	}
}
public class Test2 {
	public static void main(String[] args) {
		try {
		a(2,"猫");
		} catch (LegException e) {
			// TODO: handle exception
		}
		System.out.println("正常运行");
	}
	public static void a(int leg,String animal)throws LegException {
		if("猫".equals(animal) && leg ==4) {
			System.out.println("猫四条腿");
		}else {
			System.out.println("腿数不正确");
		}
	}
}
public class SexException extends RuntimeException{
	public SexException() {
		super();
	}
	public SexException(String message) {
		super(message);
	}
}
public class Test {
	public static void main(String[] args) {
		try {
			a("呵呵");
		} catch (SexException e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
			}
		System.out.println("正常运行");
	}
	public static void a(String gender) throws SexException {
		if("男".equals(gender) || "女".equals(gender)) {
			System.out.println("性别正常");
		}else {
			throw new SexException("性别超过正常范围");
		}		
	}
}
Echoxxxxx
关注
java学习笔记32：内部类：静态和非静态内部类、匿名内部类、方法内部类
任性的生鱼片 的博客
02-06 871
一、内部类 内部类(innerclasses)：把一个类放在另一个类的内部定义 　　 　　内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰。 注意 　　内部类只是一个编译时概念，一旦我们编译成功，就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为In...
Java 内部类，匿名内部类的使用方式和注意事项
Java Punk
02-27 2008
"内部类"在java开发中的应用场景并不是很多，但面试中却或多或少的会涉及到，所以，今天小编就带大家来温习一下。 正文： “内部类"简单说就是在一个类的内部又定义了一个类，这个定义在已知类内部的类就称为"内部类”。由于是定义在一个已知类的内部，所以它既具备一个累的特征，又在很多方面的表现和普通类有不同。 下面，我打算从两个方面来讲解内部类的使用，并验证内部类的概念： 一、在普通类中定义的内部类（不
内部类和异常
weixin_44125071的博客
01-07 252
内部类 局部内部类有两种：分别是局部类()和匿名局部类 内部类有两种: 正常内部类和静态内部类 1. 四个内部类的名字 正常内部类：OuterClass$InnerClass.class public class OuterClass { class InnerClass{ } } 静态内部类: OuterClass$InnerClass.class ,和正常内部类的名字是一样的 public class OuterClass { static class InnerCla
内部类 异常
weixin_43372380的博客
05-24 120
内部类就是在一个类的内部定义一个类，比如 a类中定义一个b类 ，那么b类相对类来说就称为内部类，而a内相对b类来说就是外部类 成员内部类 package com.oop.dome04.Dome10; //内部类 public class Outer { private int id = 10; public void out(){ System.out.println("这是一个外部类的方法"); } public class Inner{
黑马程序员——内部类 异常
night123789的专栏
12-30 398
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 一，内部类 一，概述         将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。 二，访问规则         1，内部类可以直接访问外部类中的成员，包括私有。               之
内部类与异常类
wangzhaoweng的博客
02-06 415
8.1内部类  1java支持在一个类中声明另一个类，这样的类称之为内部类，包含内部类的类称之为外嵌类，外嵌类的成员变量在内部类中依然有效，内部类的方法在也可以调用外嵌类的方法。 8.2匿名类    1.没有显明的声明一个类的子类，但又想用子类创建一个对象。我们可以直接用匿名类创建一个对象，         加入Bank是类，下面就是用它的子类(匿名类)创建的对象         new
Java——内部类与异常
weixin_43804085的博客
10-31 522
内部类与异常内部类异常 内部类 可以将其作为类中的一个普通成员变量，只不过成员变量是class的类型 一个Java文件中能够包含多个class，但是只能存在一个public class，内部类就是将一个类定义在另一个类当中。 使用：在创建内部类是，与之前有所不同，需要在前面添加外部类进行修饰 Inner.In in = new Inner().new In(); 特点： 内部类可以访问外部类的私有属性 外部类不能访问内部类的私有属性，但是如果创建了内部类对象，可以通过此内部类对象对其私有属性进行
整理java读书笔记十五之java中的内部类
09-03
4. **匿名内部类**： - 匿名内部类是没有名字的内部类，常用于实现接口或继承类，并且只需要一次使用的场景。 - 它可以是成员内部类，也可以是局部内部类。 - 通常用于简化代码，例如在事件监听器或回调函数中。 ...
java代码笔记2010-06-01：Java内部类 静态内部类 局部内部类 明明内部类；StringBuffer reverse的使用；
03-18
内部类可以分为四种类型：静态内部类、成员内部类（非静态内部类）、局部内部类和匿名内部类。 1. **静态内部类**： 静态内部类与普通的成员内部类不同，它不持有对外部类的引用。因此，可以像其他静态成员一样，...
Java内部类基础笔记
03-19
本篇笔记将详细介绍Java中的四种内部类：普通内部类、静态内部类、方法内部类以及匿名内部类。 ### A. 普通内部类 普通内部类（也称为成员内部类）是定义在外部类的成员位置，如同字段一样。它们可以直接访问外部...
内部类和异常的详解
超级程序诞生的博客
04-26 739
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就是内部类，而A类相对于B类就是外部类。 1.成员内部类 package com.rgf.oop.Demo11; //外部类通过创建外部对象来创建内部对象再调用内部方法。 public class Outer { private int id=10; public void out(){ System.out.println("这是外部类的方法"); } public
内部类和异常处理体系
sinat_20602107的博客
07-17 618
IO流： 用来处理不同设备间数据的传输问题 Java中用于操作的类都在io包中 IO流分类： 按照流向分： 输入流：读取操作 输出流：写入操作 按照数据分： 字节流： 字符流：字符流的出现就是为了解决文本数据的问题 1个字符=2个字节 绝对路径：一盘符开始的路径 相对路径：相对于某个文件或项目而言 File类：数据在硬盘上最
Java中内部类和异常处理
风吹无迹雨落无痕
04-06 2095
1 内部类内部类的访问规则： 1） 内部类可以访问外部类的成员包括私有。 之所以可以直接访问外部类的成员，是因为内部类持有一个外部类的引用 ， 格式： 外部类名.this 2） 外部类要访问内部类，必须建立内部类对象。 当内部类处于外部类的成员位置且非私有，可以在其他外部类中建立内部类对象 格式: 外部类名.内部类名 变量名 = new 外部类名（）.new 内部类名（
Java---异常类与内部类复习笔记
weixin_46666517的博客
01-02 242
文章目录内部类（了解）匿名类（无所谓）异常类（重点）try-catch语句自定义异常类 内部类（了解） Java支持在一个类中定义另一个类，这样的类称为内部类，而包含内部类的类称为内部类的外嵌类 关系： 内部类的外嵌类的成员变量在内部类中仍然有效 内部类的类中不可以声明类变量与类方法，外嵌类可以用内部类作为成员变量 内部类仅仅在它的外嵌类中，其他类部可以调用 内部类的字节码形式 “外嵌类名＄内部类名”.class 内部类可以被修饰为static类，这样就可以可以在其它类中实用static内部类来创建对象
Java笔记总结（三十）---匿名内部类
不学习，永远发现不了自己的潜力
03-23 518
匿名内部类：有的类只想用一次，可以简化开发 内部类实现接口，运行类型就是接口的类型，编译类型是jvm底层自己创建的内部类名，是内部类名$1，创建类之后又创建了实例，并且把地址返回给引用对象 匿名内部类使用一次，不能再使用 内部类实现接口 public class Happy { public static void main(String[] args) { May may = new May(); may.Banaer(); } } class May{
Java成员内部类、静态内部类、局部内部类、匿名内部类详解
sun10367的博客
08-17 438
目录成员内部类定义成员内部类特点如何使用成员内部类静态内部类定义静态内部类的特点如何使用静态内部类局部内部类定义局部内部类的特点如何使用局部内部类匿名内部类定义前提格式：匿名内部类的特点如何使用匿名内部类 成员内部类 定义 成员内部类 ：定义在外部类中方法外的类 定义格式： [public] class 外部类名 [extends 外部类的父类] [implements 外部类的父接口们] { [修饰符] class 内部类名 [extends 非静态内部类自己的父类] [implements
Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类）
JHDHCBJka的博客
02-01 330
目录 一、成员内部类 二、静态内部类 三、局部内部类： 四、匿名内部类 　首先看看什么是内部类：在类的内部定义另一个类。没错，定义就这么简单。如果在类Outer的内部再定义一个类Inner，此时Inner就称为内部类，而Outer则称为外部类。内部类的定义格式如下： public class 外部类的名称{ //外部类的成员 public class 内部类的名称{ //内部类的成员 } } 使用内部类有什么好处； 1）实现多重继承; .
2.内部类
自我学习总结
03-15 167
文章目录一.内部类二.实例内部类三.静态内部类四.局部内部类五.匿名内部类（Anonymous） 一.内部类 类中定义的成员： 字段，方法，内部类 内部类：定义在类结构中的另一个类： 增强封装，把内部类隐藏在外部类之内，不许其他类访问内部类 内部类能提高代码的可读性和可维护性，把小型类嵌入到外部类中结构上代码更靠近 内部类可以直接访问外部类的成员。 内部类根据使用不同的修饰符分类 实例内...
TypeScript 学习笔记--- interface 、enum
一撇一画的博客
02-20 3035
//interface 感觉接口主要就是用来约束传参属性的，就只能传{sex：xxxxx}的形式 interface Person { sex:String } function marry (x:Person,y:Person){ if(x.sex !== y.sex) { return '可以 marry' } else { th...
Java内部类详解：成员内部类与访问特性
以下是一些重要的Java概念，包括匿名对象、构造代码块、this关键字、static关键字、super关键字、instanceof关键字以及内部类。 1. **匿名对象**：匿名对象是指没有名字的对象，它是在创建时直接实例化的类的一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值