JAVA面向对象总结-CSDN博客

本文链接：https://blog.csdn.net/2401_86089851/article/details/140079079

一.final关键字

1.1 final关键字的概述

final ：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。

方法：被修饰的方法，不能被重写。

变量：被修饰的变量，就只能赋值一次 , 不能被重新赋值。

1.2 final关键字的使用

1.2.1 修饰类

格式如下：

修饰 final class类名 {

}

public final class fu{

}
public class zi /*extends final Class FU*/{
}

我们学习过的类，都是被 final 修饰的，目的就是供我们使用，而不让我们所

以改变其内容。

1.2.2 修饰方法

格式如下

修饰符 final 返回值类型 方法名(参数列表){
//方法体
}

public class Fu {
public final void show(){
}
}
public class Zi extends Fu {
/*@Override
public void show() {
}*/
// 无法重写父类中的show方法,因为父类中的show方法被final修饰了
}

1.2.3 修饰变量

被 final 修饰的常量名称，一般都有书写规范，所有字母都大写

局部变量

public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int NUM;
// 第一次赋值
NUM = 10;
// 第二次赋值
NUM = 20; // 报错,不可重新赋值
}
}

//引用类型的局部变量，被final修饰后，只能指向一个对象。但是不影响对象内
//部的成员变量值的修改，代码如下：
public class Demo2 {
public static void main(String[] args) {
// 创建 User 对象
final User U = new User();
// 创建 另一个 User对象

// U = new User(); // 报错，指向了新的对象，地址值改变。
// 调用setName方法
U.setName("张三"); // 可以修改
}
}

成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

显示初始化

public class FinalVariable {
final int NUM1 = 10;
}

构造方法初始化

public class FinalVariable {
final int NUM2;
public FinalVariable(int NUM2){
this.NUM2 = NUM2;
}
public FinalVariable(){
this.NUM2 = 10;
}
}

二.static关键字

2.1 static关键字概述

static 关键字 ：静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被 static 修饰

的成员 , 我们叫做静态成员

static关键字特点

静态成员被所类的所有对象共享

可以通过对象调用 , 也可以通过类名调用 , 建议使用类名

public class Student {
static String city;
public static void method(){
System.out.println("method...");
}
}

public class DemoTest {
public static void main(String[] args) {
Student.city="长沙";
Student stu01=new Student();
System.out.println(stu01.city);
stu01.method();
Student.method();
Student stu02=new Student();
System.out.println(stu02.city);
}
}

static关键字使用场景

静态变量:当程序中的某个数据需要共享时使用static修饰
静态方法:工具类

2.2 static关键字注意事项

静态方法中只能调用静态成员

非静态方法中可以调用任何成员

public class Student {
static String city;
public static void method(){
System.out.println(city);
show();
System.out.println("method...");
}
public static void show(){
System.out.println("show...");
}
public void run(){
System.out.println(city);
show();
}
}

2.3 静态代码块

三种代码块{ 代码块 }, 其中两种没有使用价值
了解:局部代码块 方法中
了解:构造代码块 写在类中,创建对象的时候运行
掌握:静态代码块 写在类中, static{} 在使用类的成员的时候,仅仅执行一
次

public class Student {
{
System.out.println("构造代码块执行了...");
}
static {
System.out.println("静态代码块执行了...");
}
}

public class DemoTest {
public static void main(String[] args) {
{
int a=10;
System.out.println(a);
}
Student stu01=new Student();
Student stu02=new Student();
}
}

三.接口

3.1 接口概述

接口是功能的集合。接口的内部主要就是 定义方法 ，包含常量，抽象方法

（ JDK 7 及以前），默认方法和静态方法（ JDK 8 ） , 私有方法 (JDK9) 。

接口不能创建对象；接口是用来被类实现（ implements ）的，实现接口的

类称为实现类。

好处：

功能的定义与实现分离，优化了程序设计。

程序的扩展性

3.2 接口的定义

定义接口的关键字使用 interface

接口中可以定义变量，变量有固定的修饰符修饰： public static final 。

接口中的变量也称之为常量，其值不能改变。

接口中可以定义方法，方法有固定的修饰符， public abstract

public interface 接口名 {
public static final 数据类型 变量名 = 值
public abstract 返回值类型 方法名字(参数列表);
}

public interface MyInterface {
//固定修饰符 public static final 常量
public static final int N=10;
int M=20;
//固定修饰符 public abstract 抽象方法
public abstract void method01();
public void method02();
}

3.3 类实现接口

类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关

键字不同，实现使用 implements 。实现类需要重写接口中所有的抽象方

法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

public interface MyInterface {
//固定修饰符 public static final 常量
public static final int N=10;
int M=20;
//固定修饰符 public abstract 抽象方法
public abstract void method01();
public void method02();
}
----------------------------------------------------------
---------------------
public class MyInterfaceImpl implements MyInterface{

@Override
public void method01() {
System.out.println("method01...");
}
@Override
public void method02() {
System.out.println("method02...");
}
}

public class DemoTest {
public static void main(String[] args) {
//常量被静态修饰,接口的名字直接调用
System.out.println(MyInterface.N);
MyInterfaceImpl my=new MyInterfaceImpl();
System.out.println(my.M);
my.method01();
my.method02();
}
}

3.4 接口的多实现

public interface MyInter01 {
public void show01();
}
----------------------------------------------------------
---------------------
public interface MyInter02 {
public void show02();
}

----------------------------------------------------------
---------------------
public class MyInterImpl implements MyInter01, MyInter02 {
@Override
public void show01() {
System.out.println("show01...");
}
@Override
public void show02() {
System.out.println("show02...");
}
}
----------------------------------------------------------
---------------------
public class DemoTest {
public static void main(String[] args) {
MyInterImpl my=new MyInterImpl();
my.show01();
my.show02();
}
}

3.5 继承类同时实现接口

public interface MyInter01 {
public void show01();
}
----------------------------------------------------------
---------------------
public interface MyInter02 {
public void show02();
}

----------------------------------------------------------
---------------------
public abstract class Fu{
public abstract void show03();
}
----------------------------------------------------------
---------------------
public class MyInterImpl extends Fu implements MyInter01,
MyInter02 {
@Override
public void show01() {
System.out.println("show01...");
}
@Override
public void show02() {
System.out.println("show02...");
}
@Override
public void show03() {
System.out.println("show03...");
}
}
----------------------------------------------------------
---------------------
public class DemoTest {
public static void main(String[] args) {
MyInterImpl my=new MyInterImpl();
my.show01();
my.show02();
my.show03();
}
}

3.6 接口新增方法

public interface 接口名称 {
常量(JDK7及其以前)
抽象方法(JDK7及其以前)
默认方法(JDK8额外增加)
静态方法(JDK8额外增加)
私有方法(JDK9额外增加)
}

public interface MyInter {
/*
默认方法:默认的修饰符是 public default,public可以省
略,default不可以省略
可以继承,也可以重写,重写需要去掉default关键字
*/
public default void method01(){
System.out.println("method01...");
}
/*
静态方法:静态方法只能通过接口名调用,不能通过实现类名字和对象
调用
*/
public static void method02(){
System.out.println("method02...");
}
/*
私有方法:只能在接口中直接调用
*/
// private void method03(){
// System.out.println("mthod03....");

// }
}
----------------------------------------------------------
---------------------
public class MyInterImpl implements MyInter{
// @Override
// public void method01() {
//
// System.out.println("impl...method01...");
//
// }
}
----------------------------------------------------------
---------------------
*/
public class DemoTest {
public static void main(String[] args) {
MyInterImpl my=new MyInterImpl();
my.method01();
MyInter.method02();
}
}

3.7 接口和抽象的区别

相同

位于继承的顶端 , 用于被其他类实现或继承；

都不能直接创建对象；

都包含抽象方法, 其子类都必须覆写这些抽象方法；

不同

抽象类为部分方法提供实现, 避免子类重复实现这些方法 , 提高代码重

用性 ;

一个类只能继承一个直接父类( 可能是抽象类 ), 却可以实现多个接口 ;

(接口弥补了 Java 的单继承 )

抽象类是继承体系中应该具备的功能, 继承体系是一种 is..a 关系

接口是这个事物中的扩展功能, 继承体系是一种 like..a 关系

四.权限修饰符

在 Java 中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰

的内容会有不同的访问权限。 public ：公共的； protected ：受保护的； ( 空

的 ) ：默认的； private ：私有的

                   public   protected    （空的）    private
同一类中             √           √            √         √

同一包中(子类与无关类)√           √            √

不同包的子类         √            √

不同包中的无关类     √

package com.lzw.demo01;
public class Person {
public void show01(){}
protected void show02(){}
void show03(){}
private void show04(){}
//在同一个类中
public void show(){
show01();
show02();
show03();

show04();
}
}
----------------------------------------------------------
---------------------
package com.lzw.demo01;
public class DemoTest {
public static void main(String[] args) {
//同包不同类中
Person p=new Person();
p.show01();
p.show02();
p.show03();
//p.show04();//编译报错
}
}
----------------------------------------------------------
---------------------
package com.lzw.demo02;
import com.lzw.demo01.Person;
public class Student extends Person {
//不同包的子类
public void method(){
show01();
show02();
//show03();//编译报错
//show04();//编译报错
}
}
----------------------------------------------------------
---------------------

package com.lzw.demo02;
import com.lzw.demo01.Person;
public class DemoTest {
public static void main(String[] args) {
//不同包的无关类
Person p=new Person();
p.show01();
//p.show02();//编译报错
//p.show03();//编译报错
//p.show04();//编译报错
}
}