本文详细介绍了Java中的final关键字，用于防止类继承、方法重写和变量篡改。同时讲解了static关键字，用于修饰类变量和方法，实现静态成员的共享。接着讨论了权限修饰符public, protected, default和private的访问限制。此外，还阐述了内部类的概念，包括成员内部类和匿名内部类的定义和使用。最后，探讨了引用类型作为方法参数和返回值的情况。
第一章 final关键字
1.1 概述
学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关键字，用于修饰不可改变内容。
-
final： 不可改变。可以用于修饰类、方法和变量。
-
类：被修饰的类，不能被继承。
-
方法：被修饰的方法，不能被重写。
-
变量：被修饰的变量，不能被重新赋值。
-
1.2 使用方式
修饰类
格式如下：
final class 类名 {
}
查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。
修饰方法
格式如下：
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
重写被 final修饰的方法，编译时就会报错。
修饰变量
-
局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class Demo {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20; // 报错,不可重新赋值
// 声明变量，直接赋值，使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}
思考，如下两种写法，哪种可以通过编译？
写法1：
final int c = 0;
for (int i = 0; i < 10; i++) {
c = i;
System.out.println(c);
}
写法2：
for (int i = 0; i < 10; i++) {
final int c = i;
System.out.println(c);
}
根据 final 的定义，写法1报错！写法2，为什么通过编译呢？因为每次循环，都是一次新的变量c。这也是大家需要注意的地方。
-
局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：
public class Demo {
public static void main(String[] args) {
// 创建 User 对象
final User u = new User();
// 创建 另一个 User对象
u = new User(); // 报错，指向了新的对象，地址值改变。
// 调用setName方法
u.setName("李四"); // 可以修改
}
}
-
成员变量
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
-
显示初始化；
public class User {
final String USERNAME = "李四";
private int age;
}
2.构造方法初始化
public class User {
final String USERNAME ;
private int age;
public User(String username, int age) {
this.USERNAME = username;
this.age = age;
}
}
被final修饰的常量名称，一般都有书写规范，所有字母都大写。
第二章 static关键字
2.1 概述
static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。static修饰的成员被多个对象共享。static修饰的成员属于类，但是会影响每一个对象。被static修饰的成员又叫类成员，不叫对象的成员。
2.2 定义和使用格式
类变量
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
-
类变量：使用 static关键字修饰的成员变量。
定义格式：
static 数据类型 变量名；
static String name；
静态方法
当static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。
-
类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。
定义格式：
修饰符 static 返回值类型 方法名 (参数列表){
// 执行语句
}
-
静态方法调用的注意事项：
-
静态方法可以直接访问类变量和静态方法。
-
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
-
静态方法中，不能使用this关键字。
-
调用格式
被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。
格式：
// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)；
调用演示，代码如下：
public class Demo {
public static void main(String[] args) {
// 访问类变量
System.out.println(Student.numberStudent);
// 调用静态方法
Student.showNum();
}
}
静态代码块
-
静态代码块：定义在成员位置，使用static修饰的代码块{ }。
-
位置：类中方法外。
-
执行：随着类的加载而执行且执行一次，优先构造方法的执行。
-
格式：
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println("静态代码块执行了");
}
}
第三章 权限修饰符
3.1 概述
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
-
public：公共的
-
protected：受保护的
-
default：默认的(不写就是默认)
-
private：私有的
3.2 不同权限的访问能力
可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
-
成员变量使用
private，隐藏细节。 -
构造方法使用
public，方便创建对象。 -
成员方法使用
public，方便调用方法。
第四章 内部类
4.1 概述
什么是内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
4.2 成员内部类
-
成员内部类 ：定义在类中方法外的类。
定义格式：
class 外部类 {
class 内部类{
}
}
访问特点
-
内部类可以直接访问外部类的成员，包括私有成员。
-
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
4.3 匿名内部类
-
匿名内部类 ：是内部类的简化写法。它的本质是一个
带具体实现的父类或者父接口的匿名的子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，
-
定义子类
-
重写接口中的方法
-
创建子类对象
-
调用重写后的方法
前提
存在一个类或者接口，这里的类可以是具体类也可以是抽象类。
格式
new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};
使用方式
以接口为例，匿名内部类的使用，代码如下：
定义接口：
public abstract class FlyAble{
public abstract void fly();
}
匿名内部类直接调用方法
public class Demo {
public static void main(String[] args) {
/*
1.等号右边:定义并创建该接口的子类对象
2.等号左边:是多态,接口类型引用指向子类对象
*/
new FlyAble(){
public void fly() {
System.out.println("飞起来了");
}
}.fly();
}
}
方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递
public static void main(String[] args) {
/*
1.等号右边:定义并创建该接口的子类对象
2.等号左边:是多态,接口类型引用指向子类对象
*/
FlyAble f = new FlyAble(){
public void fly() {
System.out.println("飞起来了");
}
};
// 将f传递给showFly方法中
showFly(f);
}
public static void showFly(FlyAble f) {
f.fly();
}
简化代码如下：
public static void main(String[] args) {
/*
创建匿名内部类,直接传递给showFly(FlyAble f)
*/
showFly( new FlyAble(){
public void fly() {
System.out.println("飞起来了");
}
});
}
public static void showFly(FlyAble f) {
f.fly();
}
第五章 引用类型作为方法参数和返回值
5.1 类名作为方法参数和返回值
-
类名作为方法的形参
方法的形参是类名，其实需要的是该类的对象
实际传递的是该对象的【地址值】
-
类名作为方法的返回值
方法的返回值是类名，其实返回的是该类的对象
实际传递的，也是该对象的【地址值】
示例代码：
public class Person{
public void eat(){
System.out.println("人吃了");
}
}
public class Test{
public static void main(String[] args){
method(new Person());
Person p = method2();
}
pubic static void method(Person p){
p.eat();
}
public static Person method2(){
return new Person();
}
}
5.2 抽象类作为形参和返回值
抽象类作为形参和返回值
-
方法的形参是抽象类名，其实需要的是该抽象类的子类对象
-
方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
示例代码：
public abstract class Animal{
public abstract void eat();
}
public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
public class Test{
public static void main(String[] args){
method(new Cat());
Animal a = method2();
}
public static void method(Animal a){
a.eat();
}
public static Animal method2(){
return new cat();
}
}
5.3 接口名作为形参和返回值
-
接口作为形参和返回值
-
方法的形参是接口名，其实需要的是该接口的实现类对象
-
方法的返回值是接口名，其实返回的是该接口的实现类对象
-
-
示例代码：
public interface Fly{
public abstract void fly();
}
public class Bird implements Fly{
public void fly(){
System.out.println("飞起来了");
}
}
public class Test{
public static void main(String[] args){
method(new Bird());
Fly f = method2();
}
public static void method(Fly f){
f.fly();
}
public static Fly method2(){
return new Bird();
}
}
扫一扫
449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
