day10 static和继承

最新推荐文章于 2024-10-17 19:11:48 发布

new一个“对象”

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量118

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_52346838/article/details/125008806

版权

本学习内容来着b站：黑马程序员

注：隔了一天没写，渐渐的感觉又累起来了，我发现要学的实在太多，东西一多，人就会放弃，毕竟谁都喜欢做简单的，能不难就不难，但是人要生活，不是生活解决我们。就是我们解决生活，放弃也终究不是问题，只会欠债到后面来还，目前我也是还债的层面，写博客真的蛮不错，每天都写博客给自己喝点鸡汤哈哈哈哈哈，只要自己不认输，你就没有赢。结尾：如果你看到了这篇文章能对你有所帮助，给我点个赞或者评论也是对我更新的最大动力！感谢，内容如果有错误，欢迎各位兄弟姐妹批评指正！！！

一. static静态关键字

1.1 static是什么

代码实现： user类

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);

        //2、对象名.实例成员变量
        //System.out.println(User.name);//报错
        User u = new User();
        u.name = "张三";
        u.age = 21;
        System.out.println(u.name);
        System.out.println(u.age);
        u.onlineNumber++;
        System.out.println(u.onlineNumber);

    }
}

代码实现：测试类

public class StaticFieldDemo1 {
    public static void main(String[] args) {
        //目标：理解static修饰成员变量的作用和访问特点。
        //1、类名.静态成员变量
        System.out.println(User.onlineNumber);

        User u = new User();
        u.onlineNumber++;
        System.out.println(u.onlineNumber);

    }
}

1.2 static修饰成员变量的内存原理

1.3 static修饰成员方法的基本用法

代码实现：student类

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,32));

        //study();//报错了
        //2、对象.实例方法
        Student s = new Student();
        s.name = "猪八戒";
        s.study();
        //3、对象.静态方法(语法是可行的，但是不推荐)
        System.out.println(s.getMax(12,23));
    }
}

1.4 static的注意事项

代码实现：

public class Test3 {
    //静态成员
    public static int onlineNumber = 10;
    public static void test2(){
        System.out.println("===test2===");
    }

    /*
    实例成员
     */
    private String name;
    public void run(){
        System.out.println(name+ "跑得快");
    }
    //3、静态方法中不可以出现this关键字
    public static void test3(){
        //System.out.println(this);//this只能代表当前对象
    }

    //2、实例方法可以访问静态成员，也可以访问实例成员
    public void go(){
        System.out.println(Test3.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        System.out.println(name);
        System.out.println(this);
        run();
    }
    //1、静态方法只能访问静态成员，不能“直接”访问实例成员
    public static void test(){
        System.out.println(Test3.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        //System.out.println(name);//不能直接访问实例成员
        //run();
    }


    public static void main(String[] args) {
        //目标：理解static 访问相关的语法，面试笔试题，或者以后理解程序很重要的知识（拓展）

    }
}

二. 工具类

2.1 工具类是什么

代码实现：工具类

import java.util.Random;

/*
工具类
 */
public class xiaochenUtil {
    /*
    注意：由于工具类无需创建对象，所以把其构造器私有化会显得很专业！
     */
    private xiaochenUtil(){
    }

    /*
    静态方法
     */
    public static String createVerifyCode(int n){
        //开发一个验证码
        //1、定义一个变量记住验证码
        String code = "";
        //2、定义一个变量记住全部验证码字符串。
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        //3、定义一个循环生成几个随机索引，去得到几个字符
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            //4、获取随机索引对应的字符，链接给code
            int index = r.nextInt(data.length());
            code += data.charAt(index);
        }
        return code;
    }
}

代码实现：login来调用工具类

public class Login {
    public static void main(String[] args) {
        //开发一个验证码
        System.out.println(xiaochenUtil.createVerifyCode(6));

        //报错是因为工具类被私有了 xiaochenUtil i = new xiaochenUtil()
    }
}

代码实现:check来调用工具类

public class Check {
    public static void main(String[] args) {
        //开发一个验证码
        System.out.println(xiaochenUtil.createVerifyCode(6));
    }
}

三. 代码块

3.1 代码块概述

代码实现：静态代码块

import java.util.ArrayList;

public class StaticDemo1 {
    public static String schoolName;
    public static ArrayList<String> cards = new ArrayList<String>();
/*
静态代码块：有static修饰，属于类，与类一起优先加载一次，自动触发执行
作用：可以用于初始化静态资源
 */
    static {
    System.out.println("-----静态代码块被触发执行了----");
    schoolName = "黑马";
    cards.add("3");
    cards.add("4");
    }
    public static void main(String[] args) {
        //目标：先理解静态代码块
        System.out.println("----main方法执行-----");
        System.out.println(schoolName);
    }
}

代码实现：实例代码块

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);
    }
}

3.2 案例

代码实现:

import java.util.ArrayList;

public class StaticTest3 {
    /*
    1、定义一个静态的集合，这样这个集合只会加载一个，因为当前房间只需要一副牌
     */
    public static ArrayList<String> cards = new ArrayList<>();
    //2.在程序真正运行main方法前，把54张牌放进去。后续游戏就可以直接使用了
    static {
        //3、正式做牌，放到集合中去
        //a、定义一个数组存储全部点数，类型确定了，个数确定了
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //b、定义一个数组存储全部的花色：类型确定了，个数也确定了
        String[] colors = {"♥","♠","♦","♣"};
        //c、先遍历点数
        for (int i = 0; i < sizes.length; i++) {
            //sizes[i]
            //d、遍历花色
            for (int j = 0; j < colors.length; j++) {
                //color[j]
                //一张牌
                String card = sizes[i] + colors[j];
                cards.add(card);
            }
        }
        //e、单独加入大小王
        cards.add("小★");
        cards.add("大★");
    }
    public static void main(String[] args) {
        //目标：模拟游戏启动前，初始化54张牌
        System.out.println("新牌：" + cards);
    }
}

四.设计模式（单例）

4.1 什么是设计模式

4.2 单例模式

4.2.1 饿汉单例模式

代码实现： SingleInstance类

//使用饿汉单例实现单例类
public class SingleInstance {
    /*
    2.饿汉单例是在获取对象前，对象已经准备好了一个
    这个对象只能是一个，所以定义静态成员变量记住
     */
    public static SingleInstance instance = new SingleInstance();

    /*
    1.必须把构造器私有化
     */

    private SingleInstance(){

    }

}

代码实现：测试类

public class Test1 {
    public static void main(String[] args) {
        //目标：理解饿汉单例的设计步骤
        SingleInstance s1 = SingleInstance.instance;
        SingleInstance s2 = SingleInstance.instance;
        System.out.println(s1 == s2);

    }
}

4.2.2 懒汉单例模式

代码实现： SingleInstance类

//懒汉单例
public class SingleInstance2 {
    /*2、定义一个静态的成员变量负责存储一个对象。只加载一次，只有一份，
    注意最好私有化，这样可以避免给别人挖坑
     */
    private static SingleInstance2 instance;

    //3.提供一个方法，对外返回单例对象
    public static SingleInstance2 getInstance(){
        if(instance == null){
            //第一次来拿对象，此时需要创建对象
            instance = new SingleInstance2();
        }
        return instance;
    }
    //1.私有化构造器
    private SingleInstance2(){

    }
}

代码实现：测试类

public class Test2 {
    public static void main(String[] args) {
        //目标：掌握懒汉单例的设计，理解其思想
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();
        System.out.println(s1 == s2 );
    }
}

五.继承

5.1 什么是继承

代码实现：父类

//人类：父类
public class People {
    public void run(){
        System.out.println("人会跑");
    }
}

代码实现：子类

//学生类：子类
public class Student extends People{
}

代码实现：测试类

public class Test {
    public static void main(String[] args) {
        //目标：认识继承这种关系，搞清楚使用继承的好处
        Student s = new Student();
        s.run();
    }
}

5.2 继承的设计规范

代码实现:父类

//父类
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;
    }
}

代码实现：子类student

//子类
public class Student extends People{
    //独有行为，填写反馈信息
    public void writeInfo(){
        System.out.println(getName() + "写下了，学习语法好快乐");
    }
}

代码实现:子类 teacher

public class Teacher extends People {
    public void teach(){
        System.out.println(getName() + "今天我们来学第一课");
    }
}

代码实现：测试类

public class Test {
    public static void main(String[] args) {
        //目标：理解继承的思想
        Student s = new Student();
        s.setName("小陈");//使用父类的
        s.setAge(999);//使用父类的
        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.teach();
    }

}

5.3 继承的特点

代码实现：

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{
    public void eat(){
        System.out.println("动物要吃东西");
    }
    public static String location = "长隆动物园";
}
class Tiger extends Animal{

}

5.4 继承后：成员变量，成员方法的访问特点

代码实现

public class Test {
    public static void main(String[] args) {
        //目标：理解继承后成员的访问特点，就近原则
        Dog d = new Dog();
        d.run();//子类的
        d.lookDoor();//子类的
        d.showName();

    }
}

class Animal{
    public String name = "动物名";
    public void run(){
        System.out.println("动物可以跑！！");
    }

}
class Dog extends Animal{
    public String name = "狗名";
    public void lookDoor(){
        System.out.println("狗可以看门");
    }
    public void showName(){
       String name = "局部名";
        System.out.println(name);
        System.out.println(this.name);//当前子类对象的name
        System.out.println(super.name);//找父类的name

        super.run();//找父类的方法
        run();//子类的run
    }
    public void run(){
        System.out.println("狗跑的很快");
    }

}

5.5 继承后：方法重写

代码实现：

public class Test {
    public static void main(String[] args) {
        //认识方法重写
        NewPhone hw = new NewPhone();
        hw.call();
        hw.sendMsg();

    }
}
/*
新手机：子类
 */
class NewPhone extends Phone{
    //重写的方法 注意：重写方法的名称与形参列表必须与被重写的方法一模一样
    @Override//1、重写校验注解，加上之后。这个方法必须是正确重写的，这样更安全，2，提高程序的可读性，代码优雅！
    public void call(){//申明不变，重新实现
        super.call();//先用它爸的基本功能
        System.out.println("开始视频通话");
    }
    //重写的方法
    @Override
    public void sendMsg(){
        super.sendMsg();//先用爸爸的基本功能
        System.out.println("发送有趣的图片！");
    }
    //静态方法不能被重写
//    @Override
//    public static void test(){
//
//    }
}
/*
旧手机:父类前
 */
class Phone{
    public void call(){
        System.out.println("打电话！");
    }
    public void sendMsg(){
        System.out.println("发短信！");
    }
    public static void test(){

    }
}

5.6 继承后：子类构造器的特点

代码实现：父类

public class Animal {
    public Animal(){
        System.out.println("父类Animal无参数构造器被执行");
    }
}

代码实现：子类

public class Dog extends Animal{
    public Dog(){
        super();//写不写都有，默认找父类的无参数构造器执行
        System.out.println("子类Dog无参数构造器被执行");
    }
    public Dog(String name){
        super();//写不写都有，默认找父类的无参数构造器执行
        System.out.println("子类Dog有参数构造器被执行");
    }
}

代码实现：测试类

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);
    }

}

5.7 继承后：子类构造器访问父类有参构造器

代码实现：父类

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 Teacher extends People{
    public Teacher(String name,int age){
        //调用父类有参数构造器，初始化继承父类的数据
        super(name,age);

    }
}

代码实现：测试类

public class Test {
    public static void main(String[] args) {
        //目标：学习子类构造器如何去访问父类有参数构造器，还要清楚其作用
        Teacher t = new Teacher("de",18);
        System.out.println(t.getName());
        System.out.println(t.getAge());
    }
}

5.8 this,super使用总结

代码实现：student类

public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }

    /**
      如果学生不填写学校，默认这个对象的学校是黑马
     */
    public Student(String name){
        //借用本类兄弟构造器
        this(name,"黑马程序员");
    }

    public Student(String name, String schoolName) {
        super();//必须初始化父类。再初始化自己
        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) {
        //目标：理解this(.....)的作用，本类构造器中访问本类兄弟的构造器
        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());
    }
}