1、static关键字
static 是 静态 的意思，可以修饰成员变量和成员方法。static修饰成员变量表示该成员变量只在内存中 只存储一份 ，可以 被共享访问、修改。
public class User {
// 成员变量
public static int onlineNumber= 161;
private String name;
private int age;
…
}
成员变量：
静态成员变量（有static修饰，属于类，内存中加载一次）: 常表示如在线人数信息、等需要被共享的信息，可以被共享访问。类名.静态成员变量。
实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age、等属于每个对象的信息。对象.实例成员变量。
public class User {
// 在线人数信息：静态成员变量
public static int onLineNumber = 161;
// 实例成员变量
private String name;
private int age;
public static void main(String[] args) {
// 1、类名.静态成员变量
User.onLineNumber++;
// 注意：同一个类中访问静态成员变量，类名可以省略不写
System.out.println(onLineNumber);
// 2、对象.实例成员变量
// System.out.println(name);
User u1 = new User();
u1.name = "猪八戒";
u1.age = 36;
System.out.println(u1.name);
System.out.println(u1.age);
// 对象.静态成员变量(不推荐这样访问)
u1.onLineNumber++;
User u2 = new User();
u2.name = "孙悟空";
u2.age = 38;
System.out.println(u2.name);
System.out.println(u2.age);
// 对象.静态成员变量(不推荐这样访问)
u2.onLineNumber++;
System.out.println(onLineNumber);
}
}
成员方法：
静态成员方法（有static修饰，属于类），建议用类名访问，也可以用对象访问。
实例成员方法（无static修饰，属于对象），只能用对象触发访问。
使用场景：
表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。
public class Student {
private String name;
private int age;
/**
实例方法：无static修饰，属于对象的，通常表示对象自己的行为，可以访问对象的成员变量
*/
public void study(){
System.out.println(name + "在好好学习，天天向上~~");
}
/**
静态方法：有static修饰，属于类，可以被类和对象共享访问。
*/
public static void getMax(int a, int b){
System.out.println(a > b ? a : b);
}
public static void main(String[] args) {
// 1、类名.静态方法
Student.getMax(10, 100);
// 注意：同一个类中访问静态成员 可以省略类名不写
getMax(200, 20);
// 2、对象.实例方法
// study(); // 报错的
Student s = new Student();
s.name = "全蛋儿";
s.study();
// 3、对象.静态方法(不推荐)
s.getMax(300,20);
}
}工具类、工具类实例：
工具类：
工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。一是调用方便，二是提高了代码复用（ 一次编写，处处可用 ）
工具类中的方法不用实例方法做？
实例方法需要创建对象调用，此时用对象只是为了调用方法，这样只会浪费内存。
工具类的定义注意
建议将工具类的构造器进行私有，工具类无需创建对象。里面都是静态方法，直接用类名访问即可。
静态方法定义工具类：
import java.util.Random;
public class VerifyTool {
/**
私有构造器
*/
private VerifyTool(){
}
/**
静态方法
*/
public static String createCode(int n){
// 1、使用String开发一个验证码
String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
// 2、定义一个变量用于存储5位随机的字符作为验证码
String code = "";
// 3、循环
Random r = new Random();
for (int i = 0; i < n; i++) {
int index = r.nextInt(chars.length());
// 4、对应索引提取字符
code += chars.charAt(index);
}
return code;
}
}public class Login {
public static void main(String[] args) {
// 验证码：
System.out.println("验证码：" + VerifyTool.createCode(10));
}
}public class Register {
public static void main(String[] args) {
// 验证码：
System.out.println("验证码：" + VerifyTool.createCode(5));
}
}
定义数组工具类？
需求：在实际开发中，经常会遇到一些数组使用的工具类。请按照如下要求编写一个数组的工具类：ArraysUtils
① ：我们知道数组对象直接输出的时候是输出对象的地址的，而项目中很多地方都需要返回数组的内容，请在 ArraysUtils 中提供一个工具类方法 toString ，用于返回整数数组的内容，返回的字符串格式如： [10, 20, 50, 34, 100] （ 只考虑整数数组，且只考虑一维数组 ）② ：经常需要统计平均值，平均值为去掉最低分和最高分后的分值，请提供这样一个工具方法 getAverage ，用于返回平均分。（ 只考虑浮点型数组，且只考虑一维数组 ）③ ：定义一个测试类 TestDemo ，调用该工具类的工具方法，并返回结果。
public class ArrayUtils {
/**
把它的构造器私有化
*/
private ArrayUtils(){
}
/**
静态方法，工具方法
*/
public static String toString(int[] arr){
if(arr != null ){
String result = "[";
for (int i = 0; i < arr.length; i++) {
result += (i == arr.length - 1 ? arr[i] : arr[i] + ", ");
}
result += "]";
return result;
}else {
return null;
}
}
/**
静态方法，工具方法
*/
public static double getAverage(int[] arr){
// 总和 最大值 最小值
int max = arr[0];
int min = arr[0];
int sum = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] > max){
max = arr[i];
}
if(arr[i] < min){
min = arr[i];
}
sum += arr[i];
}
return (sum - max - min)*1.0 / (arr.length - 2);
}
}
public class Test2 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println(arr);
System.out.println(ArrayUtils.toString(arr));
System.out.println(ArrayUtils.getAverage(arr));
int[] arr1 = null;
System.out.println(ArrayUtils.toString(arr1));
int[] arr2 = {};
System.out.println(ArrayUtils.toString(arr2));
}
}
注意事项：
静态方法只能访问静态的成员，不可以直接访问实例成员。
实例方法可以访问静态的成员，也可以访问实例成员。
静态方法中是不可以出现this关键字的。
public class Test {
// 静态成员变量
public static int onLineNumber;
// 实例成员变量
private String name;
public static void getMax(){
// 1、静态方法可以直接访问静态成员,不能访问实例成员。
System.out.println(Test.onLineNumber);
System.out.println(onLineNumber);
inAddr();
// System.out.println(name);
// 3、静态方法中不能出现this关键字
// System.out.println(this);
}
public void run(){
// 2、实例方法可以直接访问静态成员，也可以访问实例成员
System.out.println(Test.onLineNumber);
System.out.println(onLineNumber);
Test.getMax();
getMax();
System.out.println(name);
sing();
System.out.println(this);
}
public void sing(){
System.out.println(this);
}
// 静态成员方法
public static void inAddr(){
System.out.println("我们在黑马程序员~~");
}
public static void main(String[] args) {
}
}
2、代码块
静态代码块：
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。
构造代码块：
格式：{}
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
使用场景：初始化实例资源。
public class TestDemo1 {
public static String schoolName;
public static void main(String[] args) {
// 目标：学习静态代码块的特点、基本作用
System.out.println("=========main方法被执行输出===========");
System.out.println(schoolName);
}
/**
特点：与类一起加载，自动触发一次，优先执行
作用：可以在程序加载时进行静态数据的初始化操作（准备内容）
*/
static{
System.out.println("==静态代码块被触发执行==");
schoolName = "程序员";
}
}public class TestDemo2 {
private String name;
/**
属于对象的，与对象一起加载，自动触发执行。
*/
{
System.out.println("==构造代码块被触发执行一次==");
name = "张麻子";
}
public TestDemo2(){
System.out.println("==构造器被触发执行==");
}
public static void main(String[] args) {
// 目标：学习构造代码块的特点、基本作用
TestDemo2 t = new TestDemo2();
System.out.println(t.name);
TestDemo2 t1 = new TestDemo2();
System.out.println(t1.name);
}
}静态代码块实例：
需求：
在启动游戏房间的时候，应该提前准备好54张牌，后续才可以直接使用这些牌数据。分析：
① 该房间 只需要一副牌。② 定义一个静态的 ArrayList 集合 存储 54 张牌对象， 静态的 集合 只会加载一份 。③ 在启动游戏房间前，应该将 54 张牌初始化好④ 当系统启动的同时需要准备好 54 张牌数据，此时可以用静态代码块完成。
import java.util.ArrayList;
public class StaticCodeTest3 {
/**
模拟初始化牌操作
点数: "3","4","5","6","7","8","9","10","J","Q","K","A","2"
花色: "♠", "♥", "♣", "♦"
1、准备一个容器，存储54张牌对象，这个容器建议使用静态的集合。静态的集合只加载一次。
*/
// int age = 12;
public static ArrayList<String> cards = new ArrayList<>();
/**
2、在游戏启动之前需要准备好54张牌放进去，使用静态代码块进行初始化
*/
static{
// 3、加载54张牌进去。
// 4、准备4种花色：类型确定，个数确定了
String[] colors = {"♠", "♥", "♣", "♦"};
// 5、定义点数
String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
// 6、先遍历点数、再组合花色
for (int i = 0; i < sizes.length; i++) {
// sizes[i]
for (int j = 0; j < colors.length; j++) {
cards.add(sizes[i] + colors[j]);
}
}
// 7、添加大小王
cards.add("小🃏");
cards.add("大🃏");
}
public static void main(String[] args) {
System.out.println("新牌：" + cards);
}
}
3、单例
单例模式
可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。
饿汉单例设计模式
在用类获取对象的时候，对象已经提前为你创建好了。设计步骤：
定义一个类，把构造器私有。定义一个静态变量存储一个对象。/** 目标：学会使用恶汉单例模式设计单例类 */ public class SingleInstance1 { /** static修饰的成员变量，静态成员变量，加载一次，只有一份 */ // public static int onLineNumber = 21; public static SingleInstance1 instance = new SingleInstance1(); /** 1、必须私有构造器：私有构造器对外不能被访问。 */ private SingleInstance1(){ } }
懒汉单例设计模式
在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。
设计步骤：
定义一个类，把构造器私有。定义一个静态变量存储一个对象。提供一个返回单例对象的方法/** 目标：设计懒汉单例 */ public class SingleInstance2 { /** 2、定义一个静态的成员变量用于存储一个对象，一开始不要初始化对象，因为人家是懒汉 */ private static SingleInstance2 instance; /** 1、私有构造器啊 */ private SingleInstance2(){ } /** 3、提供一个方法暴露，真正调用这个方法的时候才创建一个单例对象 */ public static SingleInstance2 getInstance(){ if(instance == null){ // 第一次来拿对象，为他做一个对象 instance = new SingleInstance2(); } return instance; } }
4、继承
Java 中提供一个关键字 extends ，用这个关键字，我们可以让一个类和另一个类建立起父子关系。public class Student extends People {}
使用继承的好处
当子类继承父类后，就可以直接使用父类公共的属性和方法了。因此，用好这个技术可以很好的我们提高代码的复用性
public class People {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}public class Student extends People{
/**
独有的行为
*/
public void study(){
System.out.println(getName() + "学生开始学习~~~~~");
}
}
public class Test {
public static void main(String[] args) {
// 创建子类对象，看是否可以使用父类的属性和行为
Student s = new Student();
s.setName("西门"); // 父类的
s.setAge(25);// 父类的
System.out.println(s.getName());// 父类的
System.out.println(s.getAge());// 父类的
s.study();
}
}继承设计规范：
子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的的属性和行为应该定义在子类自己里面。
继承案例：
需求：
在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。分析：
l 学生信息和行为（ 名称，年龄 ， 所在班级 ， 查看课表 ， 填写听课反馈 ）l 老师信息和行为（ 名称，年龄 ， 部门名称 ， 查看课表 ， 发布问题 ）l 定义角色类作为父类包含属性（ 名称，年龄 ），行为（ 查看课表 ）l 定义子类：学生类包含属性（ 所在班级 ），行为（ 填写听课反馈 ）l 定义子类：老师类包含属性（ 部门名称 ），行为（发布问题）/** 角色类 父类 */ public class Role { private String name; private int age; /** 共同行为 */ public void queryCourse(){ System.out.println(name + "开始查看课程信息~~"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }public class Student extends Role{ // 独有属性 private String className; // 独有行为 public void writeInfo(){ System.out.println(getName() + "说：今天学习感觉美美的,老师也是666~~~"); } public String getClassName() { return className; } public void setClassName(String className) { this.className = className; } }public class Test { public static void main(String[] args) { // 1、创建学生对象 Student s = new Student(); s.setName("张松松"); // 父类的 s.setAge(25); // 父类的 s.setClassName("Java999期"); // 子类的 System.out.println(s.getName()); System.out.println(s.getAge()); System.out.println(s.getClassName()); s.queryCourse(); // 父类的 s.writeInfo(); // 子类的 } }
继承的特点
①子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
②Java是单继承模式：一个类只能继承一个直接父类。
③Java不支持多继承、但是支持多层继承。
④Java中所有的类都是Object类的子类。
子类是否可以继承父类的静态成员？
有争议的知识点。
子类可以直接使用父类的静态成员（共享）
但个人认为：子类不能继承父类的静态成员。（共享并非继承）
在子类方法中访问成员（成员变量、成员方法）满足：就近原则
先子类局部范围找
然后子类成员范围找
然后父类成员范围找，如果父类范围还没有找到则报错。
public class ExtendsDemo {
public static void main(String[] args) {
Wolf w = new Wolf();
System.out.println(w.name); // 子类的
w.showName();
}
}
class Animal{
public String name = "父类动物";
}
class Wolf extends Animal{
public String name = "子类动物";
public void showName(){
String name = "局部名称";
System.out.println(name); // 局部的
System.out.println(this.name); // 子类name
System.out.println(super.name); // 父类name
}
}
如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？
可以通过 super 关键字 ，指定访问父类的成员。super. 父类成员变量 / 父类成员方法
方法重写
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
方法重写的应用场景当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。子类可以重写父类中的方法。public class Phone { public void call(){ System.out.println("打电话开始~~~"); } public void sendMessage(){ System.out.println("发送短信开始~~~"); } }public class NewPhone extends Phone{ /** 方法重写了 */ @Override public void call() { super.call(); System.out.println("支持视频通话~~~"); } /** 方法重写了 */ @Override public void sendMessage() { super.sendMessage(); System.out.println("支持发送图片和视频~~~"); } }public class Test { public static void main(String[] args) { NewPhone huawei = new NewPhone(); huawei.call(); huawei.sendMessage(); } }
@Override重写 注解@Override 是放在重写后的方法上，作为重写是否正确的校验注解。加上该注解后如果重写错误，编译阶段会出现错误提示。建议重写方法都加 @Override 注解，代码安全，优雅！
方法重写注意事项和要求
重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。私有方法不能被重写。子类重写父类方法时，访问权限必须大于或者等于父类 （ 暂时了解 ：缺省 < protected < public ）子类不能重写父类的静态方法，如果重写会报错的。
子类继承父类后构造器的特点：
子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。子类构造器的第一行语句默认都是： super() ，不写也存在 。public class Animal { public Animal(){ System.out.println("==父类Animal无参数构造器被执行==="); } }public class Cat extends Animal{ public Cat(){ super(); // 默认的，写不写都有，默认就是找父类无参数构造器 System.out.println("==子类Cat无参数构造器被执行==="); } public Cat(String n){ super(); // 默认的，写不写都有，默认就是找父类无参数构造器 System.out.println("==子类Cat有参数构造器被执行==="); } }public class Test { public static void main(String[] args) { Cat c = new Cat(); System.out.println("------------"); Cat c1 = new Cat("叮当猫"); } }
子类构造器访问父类有参构造器
super调用父类有参数构造器的作用：
初始化继承自父类的数据。如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢？
会报错。因为子类默认是调用父类无参构造器的。如何解决？
子类 构造器中可以 通过 书写 super (…) ，手动 调用父类的有参数构造器public class People { private String name; private int age; public People() { } public People(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }public class Test { public static void main(String[] args) { Student s = new Student("张三", 21, "99期"); System.out.println(s.getName()); System.out.println(s.getAge()); System.out.println(s.getClassName()); } }
this和super详情
this ：代表本类对象的引用； super ：代表父类存储空间的标识。
案例需求：
在学员信息登记系统中，后台创建对象封装数据的时候如果用户没有输入学校，则默认使用“黑马培训中心”。如果用户输入了学校则使用用户输入的学校信息。
public class Student { private String name; private String schoolName; public Student() { } public Student(String name) { // 借用兄弟构造器！ this(name, "黑马培训中心"); } public Student(String name, String schoolName) { this.name = name; this.schoolName = schoolName; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSchoolName() { return schoolName; } public void setSchoolName(String schoolName) { this.schoolName = schoolName; } }public class Test { public static void main(String[] args) { Student s1 = new Student("王亮", "清华大学"); System.out.println(s1.getName()); System.out.println(s1.getSchoolName()); Student s2 = new Student("王超"); System.out.println(s2.getName()); System.out.println(s2.getSchoolName()); } }this(...)和super(…)使用注意点：
子类通过 this (...）去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类构造器的。
注意：this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。
292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
