Java_关键字、匿名对象、内部类、访问修饰符、代码块
final关键字
概述:
继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。可是当子类继承了这些特殊类之后,就可以对其中的方法进行重写,那怎么解决呢?
要解决上述的这些问题,需要使用到一个关键字final,final的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量
特点:
- final修饰类不可以被继承,但是可以继承其他类
- class Yy {}
- final class Fu extends Yy{} //可以继承Yy类
- class Zi extends Fu{} //不能继承Fu类
- final修饰的方法不可以被覆盖,但父类中没有被final修饰方法,子类覆盖后可以加final
- class Fu {
- // final修饰的方法,不可以被覆盖,但可以继承使用
- public final void method1(){}
- public void method2(){}
- }
- class Zi extends Fu {
- //重写method2方法
- public final void method2(){}
- }
- final修饰的变量称为常量,这些变量只能赋值一次。
- final int i = 20;
- i = 30; //赋值报错,final修饰的变量只能赋值一次
- 引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。
- final Person p = new Person();
- Person p2 = new Person();
- p = p2; //final修饰的变量p,所记录的地址值不能改变
- p.name = "小明";//可以更改p对象中name属性值
p不能为别的对象,而p对象中的name或age属性值可更改。
- 修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)
- class Demo {
- //直接赋值
- final int m = 100;
- //final修饰的成员变量,需要在创建对象前赋值,否则报错。
- final int n;
- public Demo(){
- //可以在创建对象时所调用的构造方法中,为变量n赋值
- n = 2016;
- }
- }
static关键字
概述:
当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,这个方法没有访问到对象的特有数据时,方法创建这个对象有些多余。可是不创建对象,方法又调用不了,这时就会想,那么我们能不能不创建对象,就可以调用方法呢?
可以的,我们可以通过static关键字来实现。static它是静态修饰符,一般用来修饰类中的成员。
特点:
- 被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)
- class Demo {
- public static int num = 100;
- }
- class Test {
- public static void main(String[] args) {
- Demo d1 = new Demo();
- Demo d2 = new Demo();
- d1.num = 200;
- System.out.println(d1.num); //结果为200
- System.out.println(d2.num); //结果为200
- }
- }
- 被static修饰的成员可以并且建议通过类名直接访问。
访问静态成员的格式:
- 类名.静态成员变量名
- 类名.静态成员方法名(参数)
- 对象名.静态成员变量名 ------不建议使用该方式,会出现警告
- 对象名.静态成员方法名(参数) ------不建议使用该方式,会出现警告
- class Demo {
- //静态成员变量
- public static int num = 100;
- //静态方法
- public static void method(){
- System.out.println("静态方法");
- }
- }
- class Test {
- public static void main(String[] args) {
- System.out.println(Demo.num);
- Demo.method();
- }
- }
static 注意事项
- 静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。
- class Demo {
- //成员变量
- public int num = 100;
- //静态方法
- public static void method(){
- //this.num; 不能使用this/super。
- System.out.println(this.num);
- }
- }
- 同一个类中,静态成员只能访问静态成员
- class Demo {
- //成员变量
- public int num = 100;
- //静态成员变量
- public static int count = 200;
- //静态方法
- public static void method(){
- //System.out.println(num); 静态方法中,只能访问静态成员变量或静态成员方法
- System.out.println(count);
- }
- }
- main方法为静态方法仅仅为程序执行入口,它不属于任何一个对象,可以定义在任意类中
定义静态常量
开发中,我们想在类中定义一个静态常量,通常使用public static final修饰的变量来完成定义。此时变量名用全部大写,多个单词使用下划线连接。
- 定义格式:
- public static final 数据类型 变量名 = 值;
- class Company {
- public static final String COMPANY_NAME = "百度";
- public static void method(){
- System.out.println("一个静态方法");
- }
- }
当我们想使用类的静态成员时,不需要创建对象,直接使用类名来访问即可。
- System.out.println(Company.COMPANY_NAME); //打印百度
- Company.method(); // 调用一个静态方法
- 注意
接口中的每个成员变量都默认使用public static final修饰。
所有接口中的成员变量已是静态常量,由于接口没有构造方法,所以必须显示赋值。可以直接用接口名访问。
- interface Inter {
- public static final int COUNT = 100;
- }
访问接口中的静态变量
- Inter.COUNT
匿名对象
匿名对象的概念:
匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。
如:已经存在的类:
- public class Person{
- public void eat(){
- System.out.println();
- }
- }
创建一个普通对象
- Person p = new Person();
创建一个匿名对象
- new Person();
特点:
- 创建匿名对象直接使用,没有变量名。
- new Person().eat() //eat方法被一个没有名字的Person对象调用了。
- 匿名对象在没有指定其引用变量时,只能使用一次。
- new Person().eat(); 创建一个匿名对象,调用eat方法
- new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象
- 匿名对象可以作为方法接收的参数、方法返回值使用
- class Demo {
- public static Person getPerson(){
- //普通方式
- //Person p = new Person();
- //return p;
- //匿名对象作为方法返回值
- return new Person();
- }
- public static void method(Person p){}
- }
- class Test {
- public static void main(String[] args) {
- //调用getPerson方法,得到一个Person对象
- Person person = Demo.getPerson();
- //调用method方法
- Demo.method(person);
- //匿名对象作为方法接收的参数
- Demo.method(new Person());
- }
- }
内部类
- 什么是内部类
将类写在其他类的内部,可以写在其他类的成员位置和局部位置,这时写在其他类内部的类就称为内部类。其他类也称为外部类。
- 什么时候使用内部类
在描述事物时,若一个事物内部还包含其他可能包含的事物,比如在描述汽车时,汽车中还包含这发动机,这时发动机就可以使用内部类来描 述。
- class 汽车 { //外部类
- class 发动机 { //内部类
- }
- }
- 内部类的分类
内部类分为成员内部类与局部内部类。
我们定义内部类时,就是一个正常定义类的过程,同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
成员内部类
成员内部类,定义在外部类中的成员位置。与类中的成员变量相似,可通过外部类对象进行访问
- 定义格式:
- class 外部类 {
- 修饰符 class 内部类 {
- //其他代码
- }
- }
- 访问方式:
- 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
- 成员内部类代码:
定义类
- class Body {//外部类,身体
- private boolean life= true; //生命状态
- public class Heart { //内部类,心脏
- public void jump() {
- System.out.println("心脏噗通噗通的跳")
- System.out.println("生命状态" + life); //访问外部类成员变量
- }
- }
- }
访问内部类
- public static void main(String[] args) {
- //创建内部类对象
- Body.Heart bh = new Body().new Heart();
- //调用内部类中的方法
- bh.jump();
- }
局部内部类:
局部内部类,定义在外部类方法中的局部位置。与访问方法中的局部变量相似,可通过调用方法进行访问。
- 定义格式:
- class 外部类 {
- 修饰符 返回值类型 方法名(参数) {
- class 内部类 {
- //其他代码
- }
- }
- }
- 访问方式:
在外部类方法中,创建内部类对象,进行访问
代码:
定义类:
- class Party {//外部类,聚会
- public void puffBall(){// 吹气球方法
- class Ball {// 内部类,气球
- public void puff(){
- System.out.println("气球膨胀了");
- }
- }
- //创建内部类对象,调用puff方法
- new Ball().puff();
- }
- }
访问内部类:
- public static void main(String[] args) {
- //创建外部类对象
- Party p = new Party();
- //调用外部类中的puffBall方法
- p.puffBall();
- }
内部类的实际使用——匿名内部类
匿名内部类概念:
内部类是为了应对更为复杂的类间关系。最常用到的内部类就是匿名内部类,它是局部内部类的一种。
定义的匿名内部类有两个含义:
- 临时定义某一指定类型的子类
- 定义后即刻创建刚刚定义的这个子类的对象
匿名内部类的作用与格式
作用:匿名内部类是创建某个类型子类对象的快捷方式。
格式:
- new 父类或接口(){
- //进行方法重写
- };
- //已经存在的父类:
- public abstract class Person{
- public abstract void eat();
- }
- //定义并创建该父类的子类对象,并用多态的方式赋值给父类引用变量
- Person p = new Person(){
- public void eat() {
- System.out.println(“我吃了”);
- }
- };
- //调用eat方法
- p.eat();
使用匿名对象的方式,将定义子类与创建子类对象两个步骤由一个格式一次完成,。虽然是两个步骤,但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用,则也是匿名对象。代码如下:
- new Person(){
- public void eat() {
- System.out.println(“我吃了”);
- }
- }.eat();
访问修饰符
在Java中提供了四种访问权限,使用不同的访问权限时,被修饰的内容会有不同的访问权限,以下表来说明不同权限的访问能力:
public |
protected |
default |
private |
|
同一类中 |
√ |
√ |
√ |
√ |
同一包中(子类与无关类) |
√ |
√ |
√ |
|
不同包的子类 |
√ |
√ |
||
不同包中的无关类 |
√ |
归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问
- 要想仅能在本类中访问使用private修饰;
- 要想本包中的类都可以访问不加修饰符即可;
- 要想本包中的类与其他包中的子类可以访问使用protected修饰
- 要想所有包中的所有类都可以访问使用public修饰。
- 注意:如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
代码块
局部代码块
局部代码块是定义在方法或语句中
特点:
- 以”{}”划定的代码区域,此时只需要关注作用域的不同即可
- 方法和类都是以代码块的方式划定边界的
- class Demo{
- public static void main(String[] args) {
- {
- int x = 1;
- System.out.println("普通代码块" + x);
- }
- int x = 99;
- System.out.println("代码块之外" + x);
- }
- }
结果:
普通代码块1
代码块之外99
构造代码块
构造代码块是定义在类中成员位置的代码块
特点:
- 优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作
- 每创建一个对象均会执行一次构造代码块。
- public class Person {
- private String name;
- private int age;
- //构造代码块
- {
- System.out.println("构造代码块执行了");
- }
- Person(){
- System.out.println("Person无参数的构造函数执行");
- }
- Person(int age){
- this.age = age;
- System.out.println("Person(age)参数的构造函数执行");
- }
- }
- class PersonDemo{
- public static void main(String[] args) {
- Person p = new Person();
- Person p1 = new Person(23);
- }
- }
静态代码块
静态代码块是定义在成员位置,使用static修饰的代码块。
特点:
- 它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。
- 该类不管创建多少对象,静态代码块只执行一次。
- 可用于给静态变量赋值,用来给类进行初始化。
- public class Person {
- private String name;
- private int age;
- //静态代码块
- static{
- System.out.println("静态代码块执行了");
- }
- }
Java_关键字、匿名对象、内部类、访问修饰符、代码块的更多相关文章
- Java—匿名对象/内部类/访问修饰符/代码块
匿名对象 匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量. //创建一个普通对象 Person p = new Person(); //创建一个匿名对象 new Pers ...
- -1-2 java 面向对象基本概念 封装继承多态 变量 this super static 静态变量 匿名对象 值传递 初始化过程 代码块 final关键字 抽象类 接口 区别 多态 包 访问权限 内部类 匿名内部类 == 与 equal
java是纯粹的面向对象的语言 也就是万事万物皆是对象 程序是对象的集合,他们通过发送消息来相互通信 每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象 每个对象都有它的类型 也就是 ...
- Java面向对象(概述,构造函数,类与对象的关系,this关键字,成员、局部),匿名对象的调用,构造代码块(5)
Java面向对象(概述,构造函数,类与对象的关系,this关键字,成员.局部),匿名对象的帝爱用,构造代码块(5)
- Java学习笔记:04面向对象-内部类_访问修饰符_final
04面向对象-内部类/访问修饰符/final 1.static的介绍 static:关键字,静态的 static的作用是用来修饰类中的成员 2.访问一个类中的某一个成员变量 方法一: _1.创建对象 ...
- C#关键字:访问修饰符
一.访问修饰符 访问修饰符有public.private.protected.internal和protected internal.它们是修饰在类型(类.接口.委托.结构和枚举)和类型成员(字段.属 ...
- 【转】C# 中访问修饰符
用通过代码: 类内部 using System;class Mod{ void defaultMethod() { Console.WriteLine("this ...
- 访问修饰符protected
protected(C# 参考) protected 关键字是一个成员访问修饰符. 受保护成员在其所在的类中可由派生类实例访问. 示例只有在通过派生类访问时,基类的受保护成员在派生类中才是可访问的. ...
- 访问修饰符private
private(C# 参考) private 关键字是一个成员访问修饰符. 私有访问是允许的最低访问级别. 私有成员只有在声明它们的类和结构体中才是可访问的,如下例所示: class Employee ...
- this、访问修饰符——Java笔记(五)
this 表示当前对象 谁调用方法谁就是当前对象 用static修饰的代码块里面不能使用this 方法里面有一个和字段同名的局部变量时,不能省略this this还 ...
随机推荐
- Bootstrap 文件上传插件 FileInput的使用问题
: 在使用bootstrap的文件上传插件fileinput http://plugins.krajee.com/file-input的预览功能时,删除预览图片在 bootstrap 模态框中没有用, ...
- gulpfile.js文档
gulp watch 实现监听不仅需要package.json文档,还需要gulpfile.js文档.否则无法实现. 1.gulp的安装 1.1 首先必须先安装node.js.这个可以参考之前的博客& ...
- Linux高级编程--03.make和makfile
Makefile语法基础 在Linux下,自动化编译工具是通过make命令来完成的(一些工具厂商也提供了它们自己的make命令,如gmake等),make命令的基本格式如下: make [-f mak ...
- spring boot(二):注解大全
spring boot注解 @Autowired 注解的意思就是,当Spring发现@Autowired注解时,将自动在代码上下文中找到和其匹配(默认是类型匹配)的Bean,并自动注入到相应的地方去. ...
- 【BZOJ】2565: 最长双回文串
[题意]给定小写字母字符串s,求最长的 [ 可以分成左右两个回文串的 ] 子串,n<=10^5. [算法]回文树 [题解]对于每个字符x,处理出以x结尾的最长回文串,以x开头的最长回文串,然后枚 ...
- cookie 跨域的问题
今天研究一天发现cookie无法设置除当前域名或者其父域名之外的其他domain. 这个是浏览器出于对cookie的保护造成的,也就是cookie无法跨域设置. 对于子域名也有如下规则,当前域名只能设 ...
- pytesser模块WindowsError错误解决方法
在使用pytesser做图片文字识别时遇到 WindowsError: [Error 2] 错误,报错内容如下: Traceback (most recent call last): File &qu ...
- Minimum Palindromic Factorization(最少回文串分割)
Minimum Palindromic Factorization(最少回文串分割) 以下内容大部分(可以说除了关于回文树的部分)来自论文A Subquadratic Algorithm for Mi ...
- C/C++——[05] 函数
函数是 C/C++语言中的一种程序组件单位.一个函数通常代表了一种数据处理的功能,由函数体和函数原型两部分组成.函数原型为这个数据处理功能指定一个标识符号(函数的名称).说明被处理数据的组成及其类型. ...
- scikit-learn模块学习笔记(数据预处理模块preprocessing)
本篇文章主要简单介绍sklearn中的数据预处理preprocessing模块,它可以对数据进行标准化.preprocessing 模块提供了数据预处理函数和预处理类,预处理类主要是为了方便添加到pi ...