今日内容
1 Java中的关键字
1.1 static关键字
- static关键字 :
- 静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员
static特点 :
- 静态成员被所类的所有对象共享
- 随着类的加载而加载 , 优先于对象存在
- 可以通过对象调用 , 也可以通过类名调用 , 建议使用类名
package com.itheima.static_demo;/*1 static概述2 静态成员特点1) 静态成员可以被本类所有的对象共享2) 静态成员可以通过类名调用也可以通过对象调用 , 推荐使用类名调用!3) 静态成员随着类的加载而加载 , 优先于对象存在3 静态方法的注意事项1) 非静态方法可以访问任何成员2) 静态方法中只能访问静态成员 , 要要想访问非静态成员需要使用对象调用3) 静态方法中不能使用this关键字掌握：1.如何定义静态方法 static修饰2.如何访问静态方法 类名访问3.注意：静态只能直接访问静态*/public class StaticDemo {public static void main(String[] args) {//静态变量访问Student.school = "黑马";//给静态变量赋值//静态成员可以被本类所有的对象共享//创建Student对象Student s1 = new Student();s1.name = "张三";Student s2 = new Student();s2.name = "李四";System.out.println(s1.name+","+s1.school);//张三,黑马System.out.println(s2.name+","+s2.school);//李四,黑马//非静态成员变量，不能共享，每个对象都有自己专属的数据。//静态成员可以被本类所有的对象共享//==========================//静态方法只能调用静态方法show();////通过类名调用静态方法Student.study();//非静态方法就得借助对象调用//Student.eat();new Student().eat();}public static void show() {}}
package com.itheima.static_demo;public class Student {public String name;// 非静态变量public int age;// 非静态变量public static String school; //静态变量public static void study(){// 静态方法//静态方法只能直接访问本类的静态成员//System.out.println(name);//非静态报错//对象访问System.out.println(new Student().name);System.out.println(school);//eat(); //非静态报错test();//不能存在this// this}public void eat() { //非静态方法System.out.println(name);System.out.println(school);}public static void test(){}}
static内存图解
static关键字的注意事项
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 — 默认的 — private
```java
package com.itheima.permissions_demo;
public class Animal {
public String str1 = “public”;
protected String str2 = “protected”;
String str3 = “package-private”;
private String str4 = “private”;
//本类: 所有权限都能使用
public void show() {System.out.println(str1);System.out.println(str2);System.out.println(str3);System.out.println(str4);
}
}
package com.itheima.permissions_demo; public class Cat extends Animal { //同包中子类 只有private不能访问 public void show() {
System.out.println(str1); System.out.println(str2); System.out.println(str3); //System.out.println(str4);//private}
}
package com.itheima.permissions_demo; public class Demo { public static void main(String[] args) {
//同包无关类 只有private不能访问 Animal a = new Animal(); System.out.println(a.str1); System.out.println(a.str2); System.out.println(a.str3); //System.out.println(a.str4);}
}
package com.itheima.permissions_demo.other; import com.itheima.permissions_demo.Animal; public class Dog extends Animal { //不同包中的子类： public void show() {
System.out.println(str1);//public System.out.println(str2);//protected //System.out.println(str3);//包私有 //System.out.println(str4);//私有}
}
package com.itheima.permissions_demo.other; import com.itheima.permissions_demo.Animal; public class Demo2 { public static void main(String[] args) { //不同包无关类 只能访问public Animal a = new Animal(); System.out.println(a.str1); //System.out.println(a.str2); //System.out.println(a.str3); //System.out.println(a.str4); } }
<a name="d48c0e63"></a>
## 2 代码块
<a name="edb81bf0"></a>
### 2.1 构造代码块
- 构造方法块 : 用一对大括号表示, 定义在类中方法外
- 执行时机 : 每次构造方法执行前, 都会执行构造代码块
- 作用 : 抽取构造方法中共性内容
```java
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 Demo { public static void main(String[] args) { new Student(); new Student(); new Student(); } } class Student { public static String schoolName;//静态 public String name; //非静态 static { System.out.println("静态代码块1"); schoolName = "黑马"; //静态只能直接访问静态成分 //name = "张三"; } public Student() { System.out.println("构造方法2"); } }2.3 局部代码块
成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
- 执行时机 : 正常执行(从上往下依次执行)
控制变量的局部变量的声明周期
package com.itheima.code_block.local_demo; public class Demo01 { public static void main(String[] args) { { int a = 10; System.out.println(a); } //System.out.println(a); for (int i = 0; i < 10; i++) { int sum=0; sum += i; } //System.out.println(i); //System.out.println(sum); } }3 接口
3.1 接口的介绍
接口 : 如果一个类中都是抽象方法 , 那么这个类应该是定义规则的类 , 我们应该把此类定义成接口,接口是一种引用数据类型
作用 :
定义接口的关键字使用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 {
}
```java
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版本对接口增加了一些方法新特性
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版本 :
枚举 : 当列举固定有限数据时，可以把这些数据定义为枚举类型。
- 作用 : 数据更好理解,见名之意
定义
权限修饰符 enum 枚举名称 { 枚举项1,枚举项2...; } //枚举项之间使用逗号分隔，最后使用分号结束 //使用枚举描述性别数据： public enum Sex { BOY,GIRL; }使用 : 通过枚举类型名直接引用枚举项即可，例如Sex.BOY、Sex.GIRL
注意 : 每个枚举项都相当于枚举的对象- 案例代码
交通信号灯有固定的三种颜色：红，黄，绿。判断灯的颜色，输出对应的通行方案 ```java package com.itheima.enum_demo; /**
package com.itheima.enum_demo; public class SignalDemo { public static void main(String[] args) { change(Signal.YELLOW); } public static void change(Signal signal) { switch (signal) { case RED: System.out.println(“红灯停！”); break; case GREEN: System.out.println(“绿灯行！”); break; case YELLOW: System.out.println(“黄灯亮了等一等！”); break; default: System.out.println(“灯坏了，注意安全”); } } }
- 枚举的本质 :
- 枚举其实本质上是一个类，每一个枚举项是本枚举类类型的一个对象。我们可以使用JDK提供的反编译命令，将枚举的字节码进行反编译查看
- 枚举本质上就是最终类
- 枚举项，就是枚举类的对象，而且是静态的常量。
- 有私有的构造方法
- 静态代码块
- 继承了lang包下的Enum
- 组成部分 :
- 构造器，成员方法，成员变量等 , 但是定义的成分一定要在枚举项之后，而且最后一个枚举项必须要有分号结束。<br />案例：将Sex枚举加上成员变量，成员方法，构造方法
```java
package com.itheima.enum_demo;
public enum Sex {
BOY("男孩"),GIRL("女孩");
//成员变量
private String msg;
//构造方法：一定是私有，外界不用
private Sex() {
}
private Sex(String msg) {
this.msg = msg;
}
//成员方法
public void show() {
System.out.println(msg);
}
}
- 说明：
1.YAO 对象就是由无参构造方法创建的
2.BOY和GIRL是有参构造方法创建的
3.构造方法权限一定是私有的，即使省略也是private权限。
4.show方法可以直接用枚举实例调用：Sex.BOY.show();
若有收获，就点个赞吧
0 人点赞
