First周志

已于 2024-10-31 16:38:31 修改
阅读量177 收藏 4
点赞数 4
文章标签： java 开发语言
于 2024-10-21 19:03:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63537878/article/details/143121617
版权

Java基础学习：

最常用的框架

public class Demo1 {
    public static void main(String[] args) {

//每行待运行的代码

   }

}

其次就是变量的属性与变量名需牢记

1.（整型）int num = 0;（整型的标准格式）Integer age = 18;
2.（字符串型）String name = "张三";（字符串为空时）String addr = null;
3.（布尔型）boolean flag = false;（标准格式的布尔型）Boolean success = true;
算术运算符 + - * / % ++ --
特别注意a++和a--的区别：a++先取值后运算，++a先运算后取值，当a=2时，b=a++；b结果为2，当d=2时，c=++a；c结果为3，虽然a和d都为3，但因取值的先后顺序导致b与c的结果不同。

关系运算符的> < >= <= != == ；逻辑运算符的&&（并运算）||（或运算）！（否定）；三目运算符？：例如int result=a? 1:2（若result=a时，result=1；若result！=a时，result=2）；赋值运算符 = += -= *= /= %=

 if (a > 10) {
            System.out.println("1");
        } else if (a < 7) {
            System.out.println("2");
        }else if (a < 9) { 
            System.out.println("3"); 
        }else {
            System.out.println("4");
        }
if判断，当a>10的输出1，当a<7的输出2，当7<=a且a<9的输出3,当9<=a且a<=10的输出4

        switch (a) {
            case 1:
                System.out.println("a=1");
                break;
            case 2:
                System.out.println("a=2");
                break;
            default:
                System.out.println("a=3");

switch选择，当a=1时输出“a=1”；当a=2时输出“a=2”；当a不等于1或2时输出“a=3”.

int[] arr = new int[]{1, 2, 63, 7};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

for循环(定义变量;条件;每次循环的运算){输出或计算，也可break;跳出}以上方法是常用的for循环，还有如下的增强for循环方法（另外，定义的int i只能在for循环里使用，for循环外不能使用）：

for (int i : arr) {
            System.out.println(i);
        }

while (a < 10) {
            System.out.println(a);
            a++;
            if (a == 5) { break;}
            if (a == 3) { continue;}
            System.out.println(a);a++;}
        do {System.out.println(a);
            a++; }

while循环只有条件，不满足条件时，跳出循环；do循环只做一次运行代码

方法定义及调用：

代码块类似于方法，但每次运行构造方法前必运行代码块，例如：

{

System.out.println("构造代码块执行");

}

static{

System.out.println("静态代码块执行");

}

构造方法在类中可写多个不同参数的相同重载，例如：

public class Demo {
    private int age = 18;
    public Demo(int age) {
        this.age = age;
        System.out.println("有参构造");}
    public Demo() {
        System.out.println("无参构造方法执行");}}

静态方法常用于主类使用中

public class App {
    public static void main(String[] args) {
        //普通方法调用（非静态）        
        Demo2 demo2 = new Demo2(18);
        demo2.method();
        int res = demo2.method1();
        System.out.println(res);
        //静态方法调用
        Demo2.method3();}}
public class Demo2 {
    public Demo2(int age) {
    this.age = age;
    System.out.println("年龄："+age);
}
public void method() {
    int a = 10;
    int b = 20;
    int sum = a + b;
    System.out.println("方法执行1");
}
public int method1(){
    int a = 10;
    int b = 20;
    int sum = a + b;
    System.out.println("方法执行2");
    return sum;
}
public static void method3() {
    System.out.println("静态方法直接通过类名调用，通常用于工具类"+name);
}}

封装的格式：private 属性 方法名（参数）{  ...... }。封装只能适用于此类的调用，其他类不能调用此类的封装，由此属性的大小范围可以从大到小的排序可以这样排列：default=>>abstract=>>public=>>private=>>protected。default默认方法，默认实现任何代码；对于abstract方法，只允许声明，不允许实现，而且不能使用final（final表示不可更改，表示此方法中的变量不可改变）和abstract同时修饰一个方法；public表示公开的，在其他类中都能使用；private私有的，常用于封装，只供本类使用，增大代码安全性，另外，在idea中Alt+Insert键可快速创建getter和setter方法。

Java的继承需注意，一个子类只能继承一个父类，但父类可以拥有多个子类，父类的父类可嵌套继承父类，另外子类可以重写父类的方法进行覆盖，也可直接使用父类的方法。

 interface接口是对方法的声明，接口中定义的变量会在编译的时候自动加上 public static final 修饰符。

public class ZhangSan extends People implements Job {
    private String name = "张三";
    protected String phone = "123456";
    @Override
    public void eat() {
        System.out.println(this.name + "的电话是" + this.phone);
        System.out.println(this.name + "给父亲打电话" + super.phone);
        super.eat("面条", "坐着");
    }
    public static void main(String[] args) {
        ZhangSan zs = new ZhangSan();
        zs.eat();
    }
    @Override
    public void doWork() {
        System.out.println(this.name + "正在做老师的工作");
    }
}
public class People {
private String name="悟空";
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public void eat(String food, String gesture) {
    System.out.println(name + gesture + "正在吃" + food);
}
}
public interface Job {
    void doWork();
}

枚举（enum），是一种特殊的类，通常用于表示一组固定的常量，例如季节、月份、星期天数或方向等。枚举提供了一种类型安全的方式来表示一组预定义的值，这些值是通过关键字enum定义的。（在其他类中默认添加的子类，无需再次定义便可直接使用）

以下两种枚举类和一个测试类

public enum EnumColor {
    RED, YELLOW, BLUE
}
public enum EnumFlag {
    NOEXCUTE("未执行",0),
    EXCUTING("执行中",1),
    SUCCESS("执行成功",2),
    FAILUER("执行失败",3)
    ;//重点注意这个“;”符号
    private String desc = "未执行";
    private int code = 0;
    public String getDesc() {
        return desc;
    }
    public int getCode() {
        return code;
    }
    private EnumFlag(String desc, int code) {
        this.desc = desc;
        this.code = code;
    }
}
public class App {
    public static void main(String[] args) {
        EnumColor enumColor = EnumColor.RED;
        System.out.println(enumColor);
        for (EnumColor color : EnumColor.values()) {
            System.out.println(color);
        }
        switch (enumColor) {
            case RED:
                System.out.println("这是红色....");
                break;
            case YELLOW:
                System.out.println("这是黄色");
                break;
            case BLUE:
                System.out.println("蓝色");
        }
        EnumFlag enumFlag = EnumFlag.NOEXCUTE;
        System.out.println(enumFlag);
        System.out.println("描述："+enumFlag.getDesc()+"状态码："+enumFlag.getCode());
    }
}

匿名内部类，在测试类中直接实例化接口，如下：

public interface Peo {
    String Sname = "张三";
    void eat();
}
public class App {
    public static void main(String[] args) {
        Peo person = new Peo() {
        @Override
        public void eat() {
            System.out.println("吃饭");
    }
};
person.eat();}

成员内部类，调用其他类时，在其他类的内部又定义了类就叫成员内部类，如下：

public class Body {
    private String arm = "两只胳膊";
    class Heart{
        String name = "心脏";
        public void work(){
            System.out.println(name+"在跳动");
            System.out.println(name+"在给"+arm+"供血");
        }
    }
}
public class App {
public static void main(String[] args) {
        Body body = new Body();
        Body.Heart heart = body.new Heart();
        heart.work();}

静态内部类，调用其他类时，在其他类的内部又定义了静态的类就叫静态内部类，如下：

public class Body {
    private String arm = "两只胳膊";
    private static String leg = "两条腿";
    static class Heart{
        String name = "心脏";
        public void work(){
            System.out.println(name+"在跳动");
            System.out.println(name+"在给"+leg+"供血");
        }
    }
}
public class App { 
        public static void main(String[] args) {
                Body.Heart heart = new Body.Heart();
                heart.work();}

局部内部类，在其他类的内部构建类中构建方法并调用

public class School {
    public void start() {
        class Teacher {
            String name = "张老师";
            public void teach() {
                System.out.println("开学上第一节课");
            }
        }
        Teacher teacher = new Teacher();
        teacher.teach();
    }
}
public class App {
        public static void main(String[] args) {
                School school = new School();
        school.start();}

java本身自带的类/方法（不同Java版本下方法可能不同，一般越新版本越多方法接口）：

String st.equal("参数")，看参数是否与变量st相等，相等st.equal("参数")返回true，否则返回false；st.startsWith()返回字符串的第一个值;st.concat("参数")拼接两个字符串；st.replace("被改的参数","换掉用的参数")用一字符替代另一字符；还有类似的cantain()包含、split()分割，trim()去除前后的空格等，也可以对字符串使用多个接口，如下：

String[] arr = str.replace("，", ",").split(",");

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值