目录
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()之后，打印这个对象，打印的是对象的属性值
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
