Java基础学习记录~~

漆黑骑士

已于 2022-06-28 14:23:32 修改

阅读量123

点赞数 1

分类专栏：开发技能汇总文章标签： java 学习开发语言

于 2022-06-07 18:23:35 首次发布

本文链接：https://blog.csdn.net/weixin_50902154/article/details/125169132

版权

开发技能汇总专栏收录该内容

15 篇文章 0 订阅

订阅专栏

static

作用： 封装工具类代码块单例

被该关键字修饰，为静态变量或方法，

无需实例化就可通过类名来调用。

工具类的构造器尽量私有化，通过静态变量获取。

public static String name = "王伟琪";

public static  getName (){
    return this.name
}

静态块

static:{ }

class 类的执行顺序，执行静态块， main 方法，解析成员方法和成员变量，构造函数，

单例模式

饿汉单例设计模式

1.定义一个类，把构造器私有

2.定义静态变量存储一个对象

//饿汉单例的设计步骤
/*
    1.定义静态变量保存类的实例，静态变量只加载一次
    2.构造方法为私有，将构造函数藏起来
    3. 利用变量获取类中静态方法  多个变量共享同一个实例
 */
public class Single {
    public static Single insTance = new Single();
    private  Single(){

    }
    public static void main(String[] args) {
        Single s1 = Single.insTance;
        Single s2 = Single.insTance;
        Single s3 = Single.insTance;
    }
}

懒汉单例模式

class lanhanSingle {
    private static  lanhanSingle Instance;
    private  lanhanSingle(){

    }
    public static  lanhanSingle getInstance(){
        if(Instance==null){
            Instance = new lanhanSingle();
        }
        return Instance;
    }
    public static void main(String[] args) {

    }
}

继承

子类继承父类的属性和行为。但是不能继承构造器，可以通过 super方法来调用（）

子类可以用类名访问父类静态成员，不是继承，只是共享

不支持多继承，可以多层继承

所有类都是 object 的子类

package com.java.demo01;

class Person {
    public static void prt(String s) {
        System.out.println(s);
    }

    Person() {
        prt("父类·无参数构造方法： "+"A Person.");
    }//构造方法(1)

    Person(String name) {
        prt("父类·含一个参数的构造方法： "+"A person's name is " + name);
    }//构造方法(2)
}

public class Chinese extends Person {
    Chinese() {
        super(); // 调用父类构造方法（1）
        prt("子类·调用父类”无参数构造方法“： "+"A chinese coder.");
    }

    Chinese(String name) {
        super(name);// 调用父类具有相同形参的构造方法（2）
        prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name);
    }

    Chinese(String name, int age) {
        this(name);// 调用具有相同形参的构造方法（3）
        prt("子类：调用子类具有相同形参的构造方法：his age is " + age);
    }

    public static void main(String[] args) {
        Chinese cn = new Chinese();
        cn = new Chinese("codersai");
        cn = new Chinese("codersai", 18);
    }
}

父类方法重写

@Override

重写方法与被重写方法参数，一致，权限大于被重写的方法

子类构造器默认访问父类无参构造器，再访问子类自身的。 super（）这个方法可写可不写，默认都会访问父类无参构造器

super 必须放在构造器首行，this(); 也是放在第一行，所以两者不能共存。

导包

别的包下面的类需要导包，然后使用

包下的不同类文件可以互相调用方法或访问变量

import com.java.test.lalala.hello;
new hello();

final

1.修饰的变量为只读，修改会报错

2.修饰参数的话，参数也是不可变的

3.有且只能赋值一次

4.被修饰的父类方法无法被重写

抽象类

package com.java.test.DEMO;

public abstract class Card {
    private String name;
    private double money;

    public  String getName() {
        return name;
    }

    public  void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
    public abstract void pay (double money);
}

class white extends  Card{

    @Override
    public void pay(double money) {
        System.out.println("当前消费 ：" + money);
        System.out.println("当前余额 ：" + super.getMoney());
        double rs = money*0.8;
        System.out.println("实际支付 ：" + rs);
        super.setMoney(super.getMoney()-rs);
        System.out.println("当前余额 ：" + super.getMoney());
    }
}
class gold extends Card {
    @Override
    public void pay(double money) {
        System.out.println("当前消费 ：" + money);
        System.out.println("当前消费 ：" + money);
        System.out.println("当前余额 ：" + super.getMoney());
        double rs = money*0.85;
        System.out.println("实际支付 ：" + rs);
        super.setMoney(super.getMoney()-rs);
        System.out.println("当前余额 ：" + super.getMoney());
    }
}
class  test{
    public static void main(String[] args) {
        white w = new white();
        w.setMoney(3000);
        w.setName("上坂堇");
        w.pay(1000);
    }
}

特点：

类有的，抽象类也有

抽象类中可以没有抽象方法，有抽象方法的一定是抽象类

抽象类无法实例化！

接口

可以定义方法，不写方法体

可以定义抽象方法，在实现类中定义

接口和类的关系

一个类只能继承另一个类

一个接口可以继承多个接口

一个类可以实现多个接口...但是多接口之间存在冲突则无法多继承


public interface user {
    public static final  String name = "王伟琪";

    public void run();

    public abstract void study();

    default void learn() {
        
    }
    static  void s(){
        
    }
}

package com.java.interFace;

public class me implements user {
    @Override
    public void run() {
        System.out.println("重写接口的run方法");
    }

    @Override
    public void study() {
        System.out.println("全栈的小王，lets go !");
    }

    public static void main(String[] args) {
        me m = new me();
        System.out.println(me.name);
        m.run();
    }
}

接口相关 (注意事项)

接口中的抽象方法和一般成员方法只需要方法名，无需方法体

接口中的静态方法需要接口名来调用

接口不能创建对象（对接口进行彻底的抽象）

一个类继承的父类和实现的接口有相同的方法，默认使用父类的！

多态

多态前提：有父类引用或实现，子类有方法重写

同一个对象，执行同一个行为，表现出不同的行为特征

父类型变量 = new 子类（）；

接口变量 = new 实现类（）；

方法调用编译看左边运行看右边

变量调用编译运行都看左边

        Animal dog = new dog();
        Animal rabbit = new rabbit();
         if(dog instanceof dog){
            dog dog2 = (dog) dog;
            dog2.wolf();
            }
    //多态下不能访问子类独有功能,可以通过类型强转来弥补

package com.java.polymorphic;

public abstract class Animal {
    public String name="我叫王伟琪";
    abstract  void run ();
}

class dog extends  Animal{
    public String name="我叫上坂堇";
    @Override
    void run() {
        System.out.println("狗狗向你跑过来~");
    }
}
class rabbit extends  Animal{
    public String name="我是夜魔";
    @Override
    void run() {
        System.out.println("蠢兔子向你跑过来...");
    }
}

class  test{
    public static  void go(Animal a){
        a.run();
        if(a insTanceof dog){
        dog d = (dog) a;
         d.woff();    
}
    }
    public static void main(String[] args) {
        Animal dog = new dog();
        Animal rabbit = new rabbit();
        go(rabbit);
        go(dog);
        System.out.println(dog.name);  //这里输出父类的变量
    }
}

类型强制转换

有继承关系或实现关系的就可以进行强转

多态接口综合案例

package com.java.polymorphic;

interface USB {
    void input();

    void output();
}

class keyboard implements USB {

    @Override
    public void input() {
        System.out.println("插入键盘成功");
    }

    @Override
    public void output() {
        System.out.println("拔出键盘成功");
    }

    public void keyDowm() {
        System.out.println("正在输入...");
    }
}

class mouse implements USB {

    @Override
    public void input() {
        System.out.println("插入鼠标成功");
    }

    @Override
    public void output() {
        System.out.println("拔出鼠标成功");
    }

    public void click() {
        System.out.println("正在选择...");
    }
}

public class computer {
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name;

    public void install(USB a) {
        a.input();
        System.out.println(getName() + "开机了");
        if (a instanceof keyboard) {
            keyboard kb = (keyboard) a;
            kb.keyDowm();
        } else if (a instanceof mouse) {
            mouse m = (mouse) a;
            m.click();
        }
        a.output();
    }

    public computer(String name) {
        setName(name);
    }
}

class Test {
    public static void main(String[] args) {
        computer com = new computer("微软电脑");
        USB a = new keyboard();
        USB b = new mouse();
        com.install(a);
        com.install(b);
    }
}

漆黑骑士

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础学习记录~~

static被该关键字修饰，为静态变量或方法，无需实例化就可通过类名来调用。静态块static:{ }class 类的执行顺序，执行静态块， main 方法，解析成员方法和成员变量，构造函数，单例模式饿汉单例设计模式 1.定义一个类，把构造器私有2.定义静态变量存储一个对象懒汉单例模式............
复制链接

扫一扫