目录
1 Java中的关键字
1.1 static关键字
-
static关键字 :
- 静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员
-
static特点 :
- 静态成员被所类的所有对象共享
- 随着类的加载而加载 , 优先于对象存在
- 可以通过对象调用 , 也可以通过类名调用 , 建议使用类名
-
public class Student { String name; int age; static String school; public void show() { System.out.println(name + "---" + age + "---" + school); } } /* static关键字的特点 : 1 静态成员被该类的所有对象的进行共享 2 静态成员可以通过类名调用 , 也可以通过对象进行调用 , 推荐使用类名 3 静态成员随着类的加载而加载 , 优先于对象存在 */ public class StudentTest { public static void main(String[] args) { Student.school = "传智专修学院"; Student s = new Student(); s.name = "张三"; s.age = 23; s.show(); Student s2 = new Student(); s2.show(); } }
-
static内存图解
-
static关键字的注意事项
- 静态方法中只能调用静态成员,(静态方法中要想访问非静态成员,需要使用对象调用)
- 非静态方法中可以调用任何成员
- 静态方法中不能存在this关键字
1.2 final关键字
-
final关键字 : 翻译中文代表最终的意思 , 是java的一个关键字 也是一个修饰符 , 可以修饰类 , 可以修饰方法 , 也可以修饰变量
-
final关键字修饰的特点
- final修饰的类 : 不能被继承 , 没有子类(太监类)
- fina修饰的方法 : 不能被重写
- final修饰的变量
- 基本数据类型 : 值不能改变
- 引用数据类型 : 地址不可发生改变 , 对象的属性可改变
- 注意 :
- 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
- final修饰成员变量需要注意初始化时机的问题 1) 直接赋值 , 2) 在构造方法执行完毕前赋值
-
package com.itheima.final_demo; /* final的特点 final修饰的类 , 不能被继承, 也就是没有子类 final修饰的方法 , 不能被重写 final修饰的变量 基本数据类型 : 值不可以发生改变 引用数据类型 : 地址不可发生改变 , 对象的内容可以发生改变 注意 : 1 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割 2 final修饰成员变量需要注意初始化时机的问题 1) 直接赋值 2) 在构造方法执行完毕前赋值 */ public class FinalDemo1 { public static void main(String[] args) { // final修饰的基本数据类型变量 , 值不能被修改 // final int num = 10; // num = 20; // System.out.println(num); final int[] arr = {1, 2, 3, 4, 5}; // final修饰的引用数据类型 , 地址不可改发生改变 // arr = new int[3]; // final修饰的引用数据类型 , 对象中的内容可以发生改变 arr[0] = 100; } } // final修饰的类 , 不能被继承, 也就是没有子类 //final class Person { // //} class Person { // final修饰的方法 , 不能被重写 public final void eat() { } } class Student extends Person { // final修饰成员变量需要注意初始化时机的问题 // 要么直接赋值 , 要么在构造方法执行完毕前赋值 // final int num = 10; final int num; public Student() { num = 100; } // @Override // public void eat() { // super.eat(); // } }
1.3 Java中的权限修饰符
-
详解
- public:公共的,当前模块内都可以访问
- protected:受保护的,同一个包下都可以,其他包下只有子类可以访问
- 默认权限(package-private):也称作“包私有”,同一个包下可以,其他包不允许
- private:只能本类访问
-
常用的是public和private
- public常用与修饰成员方法
- private常用于封装修饰成员变量,或者修饰构造(目的是防止外界创建本类的对象,例如工具类)
-
public – protected – 默认的 – private
修饰符 同一个类中 同一个包中子类、无关类 不同包的子类 不同包的无关类 private √ 默认 √ √ protected √ √ √ public √ √ √ √ package com.itheima.permissions_demo1; /* public -- protected -- 默认的 -- private */ public class Fu { public void method1() { } protected void method2() { } void method3() { } private void method4() { } // 同一个包中同一个类 public void show(){ method1(); method2(); method3(); method4(); } } =================================================== package com.itheima.permissions_demo1; public class Test { // 同一个包中 , 无关类 public void show(){ Fu f = new Fu(); f.method1(); f.method2(); f.method3(); // f.method4(); } } ==================================================== package com.itheima.permissions_demo1; public class Zi extends Fu { // 用一个包中 , 有子类父关系 public void show(){ method1(); method2(); method3(); // method4(); } }
package com.itheima.permissions_demo2; import com.itheima.permissions_demo1.Fu; public class Test { // 不同包中 , 无关类 public void show(){ Fu f = new Fu(); f.method1(); // f.method2(); // f.method3(); // f.method4(); } } ====================================== package com.itheima.permissions_demo2; import com.itheima.permissions_demo1.Fu; public class Zi extends Fu { // 不同包中 , 有子类父关系 public void show(){ method1(); method2(); // method3(); // method4(); } }
2 代码块
2.1 构造代码块
- 构造方法块 : 用一对大括号表示, 定义在类中方法外
- 执行时机 : 每次构造方法执行前, 都会执行构造代码块。
- 作用 : 抽取构造方法中共性内容
package com.itheima.code_block;
/*
构造代码块
*/
public class Student {
final int NUM;
{
NUM = 10;
System.out.println("构造代码块...");
}
public Student() {
System.out.println("空参构造...");
}
public Student(int a) {
System.out.println("有参构造...");
}
}
class StudentTest {
public static void main(String[] args) {
Student s = new Student();
Student s2 = new Student(10);
}
}
执行结果:
构造代码块...
空参构造...
构造代码块...
有参构造...
2.2 静态代码块
-
静态代码块 : 在一对大括号前加上static关键字 , 定义在类中方法外
-
执行时机 : 随着类的加载而加载 , 只加载一次。
-
作用 : 一般用于给静态成员初始化
package com.itheima.code_block.static_demo; /* 静态代码块 : 1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外 2 执行时机 ; 随着类的加载而执行, 只加载一次 3 可以给类中的静态成员进行初始化数据 */ public class Test { public static void main(String[] args) { new Student(); new Student(10); } } class Student { static { System.out.println("静态代码块"); } public Student() { System.out.println("空参构造"); } public Student(int a) { System.out.println("有参构造"); } }
2.3 局部代码块
- 成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
- 执行时机 : 正常执行(从上往下依次执行)
- 控制变量的局部变量的声明周期
什么是局部代码块?
任意局部代码位置都可以定义局部代码块,就是一对大括号。静态代码块,构造代码块,方法中,构造方法中都可以定义局部代码块。相比之下在方法中定义的局部代码块稍多一点
局部代码块作用?
可以限定变量的作用域,在代码执行完毕,及时释放内存
怎么找一个变量的作用域?
变量所在的那对大括号就是作用域
3 接口
3.1 接口的介绍
- 接口 : 如果一个类中都是抽象方法 , 那么这个类应该是定义规则的类 , 我们应该把此类定义成接口,接口是一种引用数据类型
- 作用 :
- 用于定义规则
- 程序的扩展性
3.2 接口的定义和特点
- 定义接口的关键字使用interface
- public interface 接口名{ … }
- 类与接口之间的关系是实现关系 , 用关键字implements进行连接
- public class 类名 implements 接口名 { … }
- 接口不能实例化
- 接口的子类我们叫做实现类
- 要么重写接口中所有的抽象方法
- 要么实现类是一个抽象类
- 注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口,调用逗号分隔 , 还可以继承一个类的同时 , 实现多个接口
package com.itheima.interface_demo;
public interface Inter {
public abstract void show();
public abstract void method();
}
interface Inter2 {
}
package com.itheima.interface_demo;
public class InterImpl extends Object implements Inter ,Inter2{
@Override
public void show() {
}
@Override
public void method() {
}
}
package com.itheima.interface_demo;
/*
1 定义接口的关键字使用interface
public interface 接口名{ ... }
2 类与接口的关系是实现关系 , 使用implements进行连接
public class 类名 implements 接口名{ ... }
3 接口不能实例化(不能创建对象)
4 接口的子类,我们叫做实现类
要么重写接口中所有的抽象方法
要么这个实现类是一个抽象类
注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口
还可以继承一个类的同时 , 实现多个接口
*/
public class InterfaceDemo1 {
public static void main(String[] args) {
// 接口不能实例化(不能创建对象)
// Inter inter = new Inter();
}
}
3.3 接口的成员特点
- 成员变量 : 都是常量 , 默认修饰符 public static final
- 构造方法 : 没有构造方法
- 成员方法 : 只能是抽象方法 , 默认修饰符 public abstract
- 关于JDK8和JDK9版本对接口增加了一些方法新特性
- JDK8之前:都是抽象方法
- JDK8版本:增加了默认方法、静态方法
- JDK9版本:增加了私有方法
package com.itheima.interface_demo;
public interface Inter {
// 是一个常量 , 默认修饰符 public static final
public static final int num = 10;
// 不存在构造方法
// public Inter(){}
public abstract void show();
public abstract void method();
}
interface Inter2 {
}
public class InterfaceDemo1 {
public static void main(String[] args) {
// 接口不能实例化(不能创建对象)
// Inter inter = new Inter();
// 成员变量被static修饰
System.out.println(Inter.num);
// 是一个常量 , 只能赋值一次
// Inter.num = 20;
}
}
3.4 接口的案例
package com.itheima.interface_demo.interface_test;
public interface player {
public abstract void play();
public abstract void pause();
public abstract void stop();
}
package com.itheima.interface_demo.interface_test;
public class MP3 implements player {
@Override
public void play() {
System.out.println("MP3开始播放音乐");
}
@Override
public void pause() {
System.out.println("MP3开始暂停");
}
@Override
public void stop() {
System.out.println("MP3开始关闭音乐");
}
}
package com.itheima.interface_demo.interface_test;
public class MP4 implements player {
@Override
public void play() {
System.out.println("MP4播放音乐");
}
@Override
public void pause() {
System.out.println("MP4暂停音乐");
}
@Override
public void stop() {
System.out.println("MP4关闭音乐");
}
}
package com.itheima.interface_demo.interface_test;
/*
需求 :
1 创建一个播放接口 player
2 定义三个抽象方法 , 播放(play),暂停(pause),停止(stop)
3 定义MP3类,MAP4类,手机类,实现接口,重写抽象方法
*/
public class PlayerTest {
public static void main(String[] args) {
MP3 mp3 = new MP3();
mp3.play();
mp3.pause();
mp3.stop();
System.out.println("=============");
MP4 mp4 = new MP4();
mp4.play();
mp4.pause();
mp4.stop();
}
}
3.5 接口中成员方法的特点
- DK8版本之前 : 只能是抽象方法
- JDK8版本 :
- 默认方法
- JDK8可以在接口中定义非抽象方法(带有方法体的方法) , 需要使用default进行修饰 , 其实就是默认方法
- 作用 : 解决接口升级的问题
- 格式 : public default 返回值类型 方法名(参数) { … }
- 注意事项 :
- 默认方法不是抽象方法 , 可以继承 , 也可以重写 , 重写需要去掉default关键字
- public 可以省略 , default不能省略
- 如果实现类实现了多个接口 , 有相同的方法声明 , 那么实现类必须重写该方法
- 静态方法
- JDK8可以在接口中定义静态方法 , 也是有方法体的方法
- 作用 : 方便调用此功能
- 格式 : public static 返回值类型 方法名(参数){ … }
- 注意事项
- 静态方法只能通过接口名调用 , 不能通过实现类名字和对象调用
- public可以省略 , static不能省略
- 默认方法
- JDK9版本 :
- 私有方法
- JDK9中新增私有方法
- 作用 : 抽取默认方法中共性内容
- 格式 : private 返回值类型 方法名(参数){ … }
- 注意 : 要想抽取静态方法中的共性内容 , 需要对私有方法加上关键字static
- 私有方法
3.6类和接口的关系:
类和类的关系:
继承关系,只能单继承,但是可以多层继承
类和接口的关系:
实现关系,可以是单实现,也可以是多实现,还可以在继承一个类的同时实现多个接口
接口和接口的关系
继承关系,可以实现单继承,也可以多继承
3.7抽象类与接口的区别
相同点:
- 抽象类和接口都是作为父类型,都不可以创建对象
不同点:
1. 成员的区别:
1. 成员变量
1. 抽象类:可以是常量也可以是变量
2. 接口:只能是常量,默认修饰符public static final
2. 成员方法
1. 抽象类:可以是抽象的,也可以是非抽象方法
2. 接口:
1. JDK8之前:只能是抽象方法,默认修饰符是public abstract
2. JDK8:增加了默认方法、静态方法
3. JDK9:增加了私有方法
3. 构造方法
1. 抽象类:有
2. 接口:没有
3. 设计理念:
1. 抽象类额可以存放事物的共性内容
2. 接口中可以存放事物的规则和事物的扩展功能
4 枚举
JDK5.0新特性,在此之前一般使用接口常量来替代
而使用Java枚举类型enum可以更贴切的表示这种常量
-
枚举 : 当一个变量有几种固定可能的取值时,就可以将它定义为枚举类型
-
作用 : 更贴切 , 加见名之意
-
定义 : public enum 枚举名{ … }
-
使用 : 通过枚举类型名直接引用枚举项即可,例如Sex.BOY、Sex.GIRL
注意 : 每个枚举项都相当于枚举的对象 -
案例代码
package com.itheima.enum_demo; public enum Sex { // 每一个枚举项都是枚举的对象 GIRL("女孩"), BOY("男孩"), YAO; // 成员变量 private String name; // 空参构造方法 private Sex() { } // 有参构造方法 private Sex(String name) { this.name = name; } // 成员方法 public String getName() { return name; } } class Test { public static void main(String[] args) { System.out.println(Sex.GIRL.getName()); System.out.println(Sex.BOY.getName()); System.out.println(Sex.YAO.getName()); } }
-
枚举的本质 :
- 枚举其实本质上是一个类,每一个枚举项是本枚举类类型的一个对象。我们可以使用JDK提供的反编译命令,将枚举的字节码进行反编译查看
- 枚举本质上就是最终类
- 枚举项,就是枚举类的对象,而且是静态的常量。
- 有私有的构造方法
- 静态代码块
- 继承了lang包下的Enum
- 枚举其实本质上是一个类,每一个枚举项是本枚举类类型的一个对象。我们可以使用JDK提供的反编译命令,将枚举的字节码进行反编译查看
final class Sex ectends java.lang.Enum<_Sex>{
public static final Sex BOY;
public static final Sex GIRL;
private static final Sex[] $VALUES;
//将所有的枚举对象返回
public static Sex[] values();
//根据枚举的常量名字符串,转换为枚举对象
public static Sex valueOf(java.lang.String);
private Sex();//构造方法
static{};//静态代码块
}
- 组成部分 :
- 构造器,成员方法,成员变量等 , 但是定义的成分一定要在枚举项之后,而且最后一个枚举项必须要有分号结束。
5Object类
根类
所有对象(包括数组),都实现这个类的方法
toString方法
Object类中toString():打印的是地址值
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
getClass():获取一个字节码对象
return getClass().getName():获取全类名(包名加类名)
hashCode():获取的是对象的哈希码值(十进制)
Integer.toHexString(hashCode()):返回十六进制值
如果一个类重写了toString()之后,打印这个对象,打印的是对象的属性值