目录
一、static静态关键字
1.static是什么、修饰成员变量的用法
static是什么：1.static是静态的意思，可以修饰成员变量和成员方法；2.static修饰成员变量表示该成员变量只在内存中存储一份，可以被共享访问、修改
成员变量分为两类：1.静态成员变量(有static修饰，属于类，内存中加载一次)：常表示如在线人数信息、等需要被共享的信息，可以被共享访问；2.实例成员变量(无static修饰，存在于每个对象中)：常表示姓名name、年龄age、等属于每个对象的信息
package com.pikaqiu.d1_static;
public class User {
/**
* 在线人数
* 注意：static修饰的成员变量-静态成员变量，只有一份，可以被共享
*/
public static int onlineNumber = 161;
/**
* 实例成员变量，无static修饰，存在于每个对象中，必须用对象名.成员变量访问
*/
private String name;
private int age;
public static void main(String[] args) {
//static修饰成员变量的作用和访问特点
//1.静态成员变量用类名访问更好: 类名.静态成员变量
System.out.println(User.onlineNumber);
//用对象访问也可以，但是不推荐: 对象名.静态成员变量
User u = new User();
u.name = "张三";
u.age = 18;
//System.out.println(User.name); //错误，实例成员变量无法使用类名访问
System.out.println(u.name);
System.out.println(u.age);
System.out.println(++u.onlineNumber);
//注意:同一个类中静态成员变量的访问可以省略类名
System.out.println(onlineNumber);
}
}
2.static修饰成员变量的内存原理
3.static修饰成员方法的基本用法
成员方法的分类：1.静态成员方法(有static修饰，归属于类)，建议用类名访问，也可以用对象访问；2.实例成员方法(无static修饰，归属于对象)，只能用对象触发访问
使用场景：表示对象自己的行为的，且方法中需要访问实例成员的，则方法必须申明成实例方法。
如果该方法是以执行一个共有功能为目的，则可以申请成为静态方法
package com.pikaqiu.d1_static;
public class Student {
/**
* 实例成员变量: 无static修饰，属于对象
*/
private String name;
/**
* 静态成员方法: 有static修饰，归属于类，可以被共享访问，用类名和对象名都可以访问
*/
public static int getMax(int age1 , int age2){
return age1 > age2 ? age1 : age2;
}
/**
* 实例方法: 属于对象,只能用对象触发访问
*/
public void study(){
System.out.println(name + "在好好学习，天天向上");
}
public static void main(String[] args) {
//1.类名.静态成员方法
System.out.println(Student.getMax(10, 3));
//注意:同一个类中静态成员方法的访问可以省略类名
System.out.println(getMax(10, 30));
//study(); //错误，只能通过对象访问
//2.对象.实例方法
Student s = new Student();
s.name = "张三";
s.study();
//3.对象.静态成员方法(语法可行，但是不推荐)
System.out.println(s.getMax(10, 34));
}
}
4.static修饰成员方法的内存原理
5.static的注意事项
static访问的注意事项：
1.静态方法只能访问静态的成员，不可以直接访问实例成员和方法；
2.实例方法可以访问静态的成员，也可以访问实例成员；
3.静态方法中是不可以出现this关键字的
package com.pikaqiu.d1_static;
public class Test3 {
/**
* 静态成员、静态方法
*/
public static int onlineNumber = 126;
public static void test2(){
System.out.println("==test2==");
}
/**
* 实例成员、实例方法
*/
private String name;
public void run(){
System.out.println(name + "跑的快~~");
}
//1.静态方法只能访问静态的成员，不可以直接访问实例成员
public static void test(){
System.out.println(Test3.onlineNumber);
System.out.println(onlineNumber);
test2();
//System.out.println(name); //错误，不能直接访问实例成员
//run(); //错误，不能直接访问实例方法
}
//2.实例方法可以访问静态的成员，也可以访问实例成员
public void go(){
System.out.println(Test3.onlineNumber);
System.out.println(onlineNumber);
test2();
System.out.println(this.name);
System.out.println(this);
run();
}
//3.静态方法中是不可以出现this关键字的
public static void test3(){
//System.out.println(this); //错误，this只能代表当前对象，而静态方法可以不用对象调用
}
public static void main(String[] args) {
test();
Test3 t = new Test3();
t.go();
}
}
二、static应用知识：工具类
1.工具类概述
工具类是什么：类中都是一些静态的方法，每个方法都是以完成一个公用的功能为目的，这个类用来给系统开发人员共同使用
使用工具类的好处：1.调用方便；2.提高了代码复用(一次编写，处处可用)
为什么工具类中的方法不用实例方法做：1.实例方法需要创建对象调用；2.此时用对象只是为了调用方法，这样只会浪费内存
工具类定义时的其他要求：由于工具里面都是静态方法，直接使用类名访问即可，因此，工具类无需创建对象，建议将工具类的构造器进行私有
package com.pikaqiu.d2_static_util;
import java.util.Random;
/**
* 工具类
*/
public class PikaqiuUtil {
/**
* 由于工具类无需创建对象，所以把其他构造器私有化会显得很专业
*/
private PikaqiuUtil(){
}
/**
* 静态方法
*/
public static String createVerifyCode(int n){
String code = "";
String data = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
Random r = new Random();
for (int i = 0; i < n; i++) {
code += data.charAt(r.nextInt(data.length()));
}
return code;
}
}
package com.pikaqiu.d2_static_util;
import java.util.Random;
public class Check {
public static void main(String[] args) {
System.out.println("验证码:" + PikaqiuUtil.createVerifyCode(6));
//PikaqiuUtil p = new PikaqiuUtil(); //错误，已经私有化
}
}
2.练习-定义数组工具类
package com.pikaqiu.d2_static_util;
/**
* 数组工具类
*/
public class ArraysUtils {
/**
* 私有构造器
*/
private ArraysUtils(){
}
/**
* 方法-返回整型数组的内容
* @param arr 传入的整型数组
* @return 整型数组的内容
*/
public static String toString(int[] arr){
if(arr == null){
return null;
}else{
String array = "[";
for (int i = 0; i < arr.length; i++) {
array += (i == arr.length - 1 ? arr[i] : arr[i] + ",");
}
array += "]";
return array;
}
}
/**
* 方法-计算平均分
* @param arr 得分数组
* @return 最终得分
*/
public static double getAverage(double[] arr){
double max = arr[0];
double min = arr[0];
double scores = 0;
for (int i = 0; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
if(min > arr[i]) {
min = arr[i];
}
scores += arr[i];
}
double average = (scores - max - min) / (arr.length - 2);
return average;
}
}
package com.pikaqiu.d2_static_util;
public class TestDemo2 {
public static void main(String[] args) {
int[] arr1 = null;
int[] arr2 = {};
int[] arr3 = {1,2,3,4};
System.out.println(ArraysUtils.toString(arr1));
System.out.println(ArraysUtils.toString(arr2));
System.out.println(ArraysUtils.toString(arr3));
double[] arr4 = {10,50,20,30,60,20};
System.out.println(ArraysUtils.getAverage(arr4));
}
}
三、static应用知识：代码块
1.代码块的分类、作用
代码块概述：1.代码块是类的5大成分之一(成员变量、构造器、方法、代码块、内部类)，定义在类中方法外；2.在Java类下，使用{}括起来的代码被称为代码块
代码块分为：1.静态代码块---格式：static{}；特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次；使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。2.构造代码块(实例代码块)---格式：{}；特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行；使用场景：初始化实例资源
package com.pikaqiu.d3_static_code;
import java.util.ArrayList;
public class StaticDemo1 {
public static String schoolName;
/**
* 静态代码块：需要通过static关键字修饰，随着类的加载而加载(优先执行！)，并且自动触发，只执行一次
* 作用：可以用于初始化静态资源
*/
static {
System.out.println("----------静态代码块执行了----------");
schoolName = "张三";
}
public static void main(String[] args) {
System.out.println("----------mian方法执行了----------");
System.out.println("----------mian方法执行了----------");
System.out.println(schoolName);
}
}
package com.pikaqiu.d3_static_code;
public class StaticDemo2 {
//private String name;
public StaticDemo2(){
System.out.println("=====无参构造器执行了=====");
}
/**
* 实例代码块：无static修饰，属于对象，每次构建对象时，都会触发一次执行
*/
{
//name = "张三";
System.out.println("=====实例代码块执行了=====");
}
public static void main(String[] args) {
StaticDemo2 s1 = new StaticDemo2();
//System.out.println(s1.name);
StaticDemo2 s2 = new StaticDemo2();
//System.out.println(s2.name);
}
}
2.静态代码块的应用案例
需求：在启动游戏房间的时候，应该提前准备好54张牌，后续才可以直接使用这些牌数据
package com.pikaqiu.d3_static_code;
import java.util.ArrayList;
public class StaticTest3 {
/**
* 定义一个静态的集合，这样这个集合只加载一次，因为当前房间仅需要一张牌
*/
public static ArrayList<String> cards = new ArrayList<>();
/**
* 使用静态代码块，在程序运行main方法之前，把54张牌放进去
*/
static {
//将牌放入集合中
//定义一个数组存储全部点数(类型确定、个数确定)
String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
//定义一个数组存储全部的花色(类型确定、个数确定)
String[] colors = {"♥","♠","♦","♣"};
//遍历-得到52张牌
for (int i = 0; i < sizes.length; i++) {
for (int j = 0; j < colors.length; j++) {
String card = sizes[i] + colors[j];
cards.add(card);
}
}
//单独加入大小王
cards.add("小" + "🃏");
cards.add("大" + "🃏");
}
public static void main(String[] args) {
System.out.println("新牌:" + cards);
}
}
四、static应用知识：单例设计模式
1.设计模式、单例模式介绍、饿汉单例模式
什么是设计模式：开发中经常遇到一些问题，一个问题通常有n种解法，但其中一定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。设计模式有20多种，对应20多种软件开发中会遇到的问题
单例模式：1.可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象；2.例如任务管理器对象，我们只需要一个就可以解决问题了，这样可以节省内存空间
饿汉单例模式：在用类获取对象的时候，对象已经提前为你创建好了
package com.pikaqiu.d4_static_singleinstance;
/**
* 使用饿汉单例实现单例类
*/
public class SingleInstance {
/**
* 2.饿汉单例是在获取对象前，对象已经被准备好了一个
* 这个对象只能是一个，所以定义静态成员变量记住
*/
public static SingleInstance instance = new SingleInstance();
/**
* 1.必须把构造类私有化
*/
private SingleInstance(){
}
}
package com.pikaqiu.d4_static_singleinstance;
public class Test {
public static void main(String[] args) {
SingleInstance s1 = SingleInstance.instance;
SingleInstance s2 = SingleInstance.instance;
System.out.println(s1 == s2); //true
}
}
2.懒汉单例模式
懒汉单例设计模式：在真正需要该对象的时候，才去创建一个对象(延迟加载对象)
package com.pikaqiu.d4_static_singleinstance;
/**
* 懒汉单例
*/
public class SingleInstance2 {
/**
* 2.定义一个静态的成员变量，负责存储一个对象
* 只加载一次，只有一份
* 注意：最好私有化，这样可以避免给别人挖坑
*/
private static SingleInstance2 instance2;
/**
* 3.提供一个方法，对外返回单例对象
*/
public static SingleInstance2 getInstance2(){
if(instance2 == null){
//第一次来拿对象，此时需要创建对象
instance2 = new SingleInstance2();
}
return instance2;
}
/**
* 1.构造器私有化
*/
private SingleInstance2(){
}
}
package com.pikaqiu.d4_static_singleinstance;
public class Test2 {
public static void main(String[] args) {
SingleInstance2 s1 = SingleInstance2.getInstance2();
SingleInstance2 s2 = SingleInstance2.getInstance2();
System.out.println(s1 == s2); //true
}
}
五、面向对象三大特征之二：继承
1.继承概述、使用继承的好处
什么是继承：Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。
继承格式：子类 extends 父类
例如：public class Student extends People{} 其中Student称为子类(派生类),People称为父类(基类或超类)
作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了
使用继承的好处：可以提高代码的复用性，增强类的功能扩展性
package com.pikaqiu.d5_extends;
/**
* 人类：父类
*/
public class People {
public void run(){
System.out.println("人跑起来了");
}
}
package com.pikaqiu.d5_extends;
/**
* 学生类：子类
*/
public class Student extends People{
}
package com.pikaqiu.d5_extends;
public class Test {
public static void main(String[] args) {
Student s = new Student();
s.run();
}
}
2.继承的设计规范、内存运行原理
继承设计规范：子类们相同特征(共性属性，共性方法)放在父类中定义，子类独有的属性和行为应该定义在子类自己里面
一个对象里面有两片空间：一个子类空间(this)；一个父类空间(super)
package com.pikaqiu.d6_extends_test;
/**
* 父类
*/
public class People {
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;
}
}
package com.pikaqiu.d6_extends_test;
/**
* 子类
*/
public class Student extends People{
/**
* 独有的行为
*/
public void writeInfo(){
System.out.println(getName() + "写下了：学习语法很happy~~~");
}
}
package com.pikaqiu.d6_extends_test;
/**
* 子类
*/
public class Teacher extends People{
/**
* 独有行为
*/
public void askQuestion(){
System.out.println(getName() + "发布了一个问题");
}
}
package com.pikaqiu.d6_extends_test;
public class Test {
public static void main(String[] args) {
Student s = new Student();
s.setName("皮卡丘"); //调用父类的
s.setAge(20); //使用父类的
System.out.println(s.getName()); //父类的方法
System.out.println(s.getAge()); //父类的方法
s.queryCourse(); //父类的方法
s.writeInfo(); //子类的方法
Teacher t = new Teacher();
t.setName("小智");
t.setAge(18);
System.out.println(t.getName()); //父类的方法
System.out.println(t.getAge()); //父类的方法
t.queryCourse(); //父类的方法
t.askQuestion(); //子类的方法
}
}
3.继承的特点
1.子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
2.Java是单继承模式：一个类只能继承一个直接父类
3.Java不支持多继承，但是支持多层继承
4.Java中所有的类都是Object类的子类
子类是否可以继承父类的私有成员：可以继承，但是不能直接访问。
子类是否可以继承父类的静态成员：个人认为不算继承，只是共享的。
Java不支持多继承的原因：假如这些父类中都有一个同样的方法，子类无法确定继承哪个的方法。
Java支持多层继承：A继承B，B继承C，这时如果B、C有同样的方法，A会继承B的，就近继承。
Object特点：Java中所有类，要么直接继承了Object，要么默认继承了Object，要么间接继承了Object，Object是祖宗类。
package com.pikaqiu.d7_extends_feature;
public class Test {
public static void main(String[] args) {
//1.子类不能直接继承父类的构造器
//2.子类是否可以继承父类的私有成员? 可以继承，但是不能直接访问
Tiger t = new Tiger();
//t.eat();
//3.子类是否可以继承父类的静态成员? 个人认为不算继承，只是共享的
System.out.println(Tiger.location);
}
}
class Animal{
private void eat(){
System.out.println("吃东西~~~");
}
public static String location = "动物园";
}
class Tiger extends Animal{
}4.继承后：成员变量、成员方法的访问特点
在子类方法中访问成员(成员变量、成员方法)满足:就近原则
先子类局部范围找；再子类成员范围找；最后父类成员范围找，如果父类范围还没找到就报错
package com.pikaqiu.d8_extends_field_method;
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
d.run(); //狗跑的贼快~~~
d.showName(); //局部名
}
}
class Animal{
public String name = "动物名";
public void run(){
System.out.println("动物可以跑~~~");
}
}
class Dog extends Animal{
public String name = "狗名";
public void run(){
System.out.println("狗跑的贼快~~~");
}
public void showName(){
String name = "局部名";
System.out.println(name); //局部名
System.out.println(this.name); //子类对象的name 狗名
System.out.println(super.name); //父类对象的name 动物名
run(); //狗跑的贼快~~~
super.run(); //动物可以跑~~~
}
}5.继承后：方法重写
什么是方法重写：子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法
方法重写的应用场景：当子类需要父类的功能，但父类的该功能不能完全满足自己的需求时，子类可以重写父类中的方法
@Override重写注解：1.@Override是放在重写后的方法上，作为重写是否正确的效验注解；2.加上该注解后如果重写错误，编译阶段会出现错误提示；3.建议重写方法都加Override注解，代码安全，优雅
方法重写注意事项和要求：1.重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致；2.私有方法不能被重写；3.子类重写父类方法时，访问权限必须大于或者等父类(缺省 < protected < public)；4.子类不能重写父类的静态方法，如果重写会报错
package com.pikaqiu.d9_extends_override;
public class Test {
public static void main(String[] args) {
NewPhone hw = new NewPhone();
hw.call();
hw.sendMsg();
}
}
/**
* 旧手机
*/
class Phone{
public void call(){
System.out.println("打电话");
}
public void sendMsg(){
System.out.println("发短信");
}
}
/**
* 新手机
*/
class NewPhone extends Phone{
//重写的方法
@Override //1.重写效验注解，加上之后，这个方法必须是正确重写的，这样更安全
//2.提高代码的可读性，代码更加优雅
//注意：重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致
public void call(){
super.call(); //先用父类的基本功能
System.out.println("开始视频通话");
}
@Override
public void sendMsg(){
//super.sendMsg(); //先用父类的基本功能
System.out.println("发送有趣的图片");
}
}6.继承后：子类构造器的特点
子类继承父类后构造器的特点：子类中所有的构造器默认都会先访问父类中的无参构造器，在执行自己
原因：1.子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据；2.子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化
怎么调用父类构造器的：子类构造器的第一行语句默认都是：super()，不写也存在
package com.pikaqiu.d10_extends_constructor;
public class Animal {
public Animal(){
System.out.println("父类Animal无参构造器被执行了");
}
}
package com.pikaqiu.d10_extends_constructor;
public class Dog extends Animal{
public Dog(){
System.out.println("子类Dog无参构造器被执行了");
}
public Dog(String name){
System.out.println("子类Dog有参构造器被执行了");
}
}
package com.pikaqiu.d10_extends_constructor;
public class Test {
public static void main(String[] args) {
Dog d1 = new Dog();
System.out.println(d1);
System.out.println("---------------");
Dog d2 = new Dog("小白");
System.out.println(d2);
}
}
7.继承后：子类构造器访问父类有参构造器
super调用父类有参数构造器的作用：初始化继承自父类的数据
package com.pikaqiu.d11_extends_constructor;
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;
}
}
package com.pikaqiu.d11_extends_constructor;
public class Teacher extends People{
public Teacher(String name,int age){
//调用父类的有参构造器，初始化并继承父亲的数据
super(name,age);
}
}
package com.pikaqiu.d11_extends_constructor;
public class Test {
public static void main(String[] args) {
Teacher t = new Teacher("皮卡丘",18);
System.out.println(t.getName());
System.out.println(t.getAge());
}
}
8.this、super使用总结
this：代表本类对象的引用；super：代表父类存储空间的标识
注意：this()和super()都只能放在构造器的第一行，所以二者不能共存在同一个构造器中
package com.pikaqiu.d12_this;
public class Student {
private String name;
private String schoolName;
public Student() {
}
/**
* 如果学生不填写学校，默认这个对象的学校是妖怪学院
* @param name 学生姓名
*/
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;
}
}
package com.pikaqiu.d12_this;
public class Test {
public static void main(String[] args) {
//理解this(...)的作用：本类构造器中访问本类兄弟构造器
Student s1 = new Student("迪莫","洛克王国");
System.out.println(s1.getName());
System.out.println(s1.getSchoolName());
System.out.println("--------------------");
Student s2 = new Student("妙蛙种子");
System.out.println(s2.getName());
System.out.println(s2.getSchoolName());
}
}
1582
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
