Java基础

Java变量

实例变量
当你实例化出一个对象，类就会帮这个对象添加一些属性这些属性就来自实例变量如果你需要传入一些参数那么你需要写类构造方法。

public class Dog {
    public String name;
    public String age;
    //类构造方法
    public Dog(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public void printInfo() {
        System.out.println(this.name);
        System.out.println(this.age);
    }

    public static void main(String[] args) {
        Dog dog1 = new Dog("big yellow", "18");
        dog1.printInfo();
    }
}

类变量
即就是这个类的静态属性你不需要实例化一个对象就可以访问到它。

public class Dog {
    public static String staticName = "Dog_Static";
    public final static String FINAL_NAME = "Dog_FINAL";

    public static void main(String[] args) {
        System.out.println(Dog.FINAL_NAME);
        System.out.println(Dog.staticName);
    }
}

局部变量

这个没什么好说的，就是正常声明的变量。

public class Dog {
    public static void main(String[] args) {
	int age = 18;
        System.out.println(age);
    }
}

参数

就是函数调用时需要传递的变量。

public class Dog {
    public static void main(String[] args) {
	int age = 18;
        System.out.println(age);
    }
    int printer(int a,int b){
	return a + b;
    }
}

Java数据类型

基本数据类型
数字型：short int long（整型） float double（浮点型）
字符型：byte char
布尔型：boolean

引用数据类型
class（类）

public class Dog {
    public static void main(String[] args) {
	int age = 18;
        System.out.println(age);
    }
    int printer(int a,int b){
	return a + b;
    }
}

interface（接口）

interface Animal {

    public static String staticName = "Dog_Static";
    public final String name = "Dog_FINAL";

    public void printInfo();
}
public class Dog implements Animal {
    public static String staticName = "Dog_Static";
    public final static String FINAL_NAME = "Dog_FINAL";

    public void printInfo() {
        System.out.println(this.name);
        System.out.println(this.age);
    }

    public static void main(String[] args) {
        System.out.println(Dog.FINAL_NAME);
        System.out.println(Dog.staticName);
    }
}

Array（数组）

int[] myList = new int[4];
int[] myList = new int[] {5,2,0,1,3,1,4};
//for each写法
 public static void main(String[] args) {
        // 初始化字符串数组 words
        int[] list = new int[] { 1, 2, 3, 4, 5 };
        for (int i : list) {
            System.out.println(i);
        }
}
//多维数组
// 创建一个3行2列的二维数组
int[][] intArray = {{1,2}, {3,4}, {5,6}};

String（字符串）
字符串存在不可变性也就是说如果我们修改一个String类型的值原先的字符串不会被销毁而是会在内存创建一个新的字符串，然后这个String类型的指针指向新的字符串之后JVM根据引用计数操作回收计数为0的变量内存

1	`String str = "hxh";`

Java面向对象

封装

外部函数无法访问内部变量（对内部变量进行保护不直接暴露出去）设置private关键字
自己手动创建get & set 方法 get用于读取变量的值 set用于写入变量的值可以在set函数中添加限制保证数据正确合理写入
可以对方法进行重载

继承

方法重写需要满足如下规则

重写方法的参数列表应该与原方法完全相同；
返回值类型应该和原方法的返回值类型一样或者是它在父类定义时的子类型；
重写方法访问级别限制不能比原方法高。例如：如果父类方法声明为公有的，那么子类中的重写方法不能是私有的或是保护的。具体限制级别参考访问修饰符；
只有被子类继承时，方法才能被重写；
方法定义为 final，将不能被重写；
一个方法被定义为 static，将使其不能被重写，但是可以重新声明；
一个方法不能被继承，那么也不能被重写；
和父类在一个包中的子类能够重写任何没有被声明为 private 和 final 的父类方法；
和父类不在同一个包中的子类只能重写 non-final 方法或被声明为 public 或 protected 的方法；
一个重写方法能够抛出任何运行时异常，不管被重写方法是否抛出异常。然而重写方法不应该抛出比被重写方法声明的更新更广泛的已检查异常。重写方法能够抛出比被重写方法更窄或更少的异常；
构造方法不能重写。

访问修饰符

private ：私有的，只允许在本类中访问；
protected ：受保护的，允许在同一个类、同一个包以及不同包的子类中访问；
默认的 ：允许在同一个类，同一个包中访问；
public ：公共的，可以再任何地方访问。

通过super调用父类的方法属性构造方法

多态

多态意味着允许不同类的对象对同一消息做出不同的响应。java中实现多态的三个条件分别是

满足继承关系
要有重写
父类引用指向子类对象（向上转型）子类引用指向父类对象（向下转型）

抽象类

可以使用 abstract 关键字声明抽象类或抽象方法。

抽象类不能被实例化，抽象类中的方法必须被非抽象子类实现，它必须被继承才能被使用。

抽象类中不一定包含抽象方法，但抽象方法一定在抽象类中。

接口

一个与抽象类相似的概念，但是两者设计理念不同。与抽象类的区别：

接口中除了 static 、final 变量，不能有其他变量，而抽象类可以；
一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口；
接口方法默认修饰符是 public ，抽象方法可以有 public 、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！）；
从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。

内部类

作用

封装内部类的成员通过外部类才能访问，对成员信息有更好的隐藏，因此内部类实现了更好的封装
多继承可以用多个内部类继承其他类的方法
可以解决继承或实现接口的方法重名问题

分类

成员内部类

// 声明以及调用方式
// 通过 new 外部类().new 内部类()的形式
public class Any {
    class OwnClass {
        public void SayOwn(){
            System.out.println("sayOwn");
        }
    }
    public static void main(String[] args) {
        OwnClass any = new Any().new OwnClass();
        any.SayOwn();
    }
}
// 在外部类中声明一个创建内部类的方法 这种方式比较优雅
public class Any {
    class OwnClass {
        public void SayOwn(){
            System.out.println("sayOwn");
        }
    }
    public OwnClass createOwn(){
        return new OwnClass();
    }
    public static void main(String[] args) {
        Any any = new Any();
        OwnClass own = any.createOwn();
        own.SayOwn();
    }
}

静态内部类

// 可以不依赖外部类直接创建内部类的实例
// 只能获取到static的外部类属性 方法
public class Any {
    String NAME = "Any";

    static class StaticClass {
        void sayStatic() {
            System.out.println("Static");
        }
    }

    public static void main(String[] args) {
        StaticClass staticClass = new StaticClass();
        staticClass.sayStatic();
    }
}

方法内部类

// 在外部类的方法中声明一个内部类
public class Any {
    String NAME = "Any";

    public void fn() {
        class StaticClass {
            public void sayFn() {
                System.out.println("FN");
            }
        }
        StaticClass staticClass = new StaticClass();
        staticClass.sayFn();
    }

    public static void main(String[] args) {
        new Any().fn();
    }
}

匿名内部类

匿名内部类没有类型名称和实例对象名称；
匿名内部类可以继承父类也可以实现接口，但二者不可兼得；
匿名内部类无法使用访问修饰符、static、abstract 关键字修饰；
匿名内部类无法编写构造方法，因为它没有类名；
匿名内部类中不能出现静态成员。

// 没有名字的内部类
public abstract class Any {
    public void run() {
        System.out.println("runing");
    }

    public static void main(String[] args) {
        Any car = new Any() {
            public void run() {
                System.out.println("car run");
            }
        };
        car.run();

        Any airPlain = new Any() {
            public void run() {
                System.out.println("airPlain fly");
            }
        };
        airPlain.run();
    }
}

Java包

java提供包的机制主要是为了避免类命名冲突的问题，你可以理解为一个文件夹就代表一个包。一个包内的类可以相互访问到。

Java进阶

String类

// 部分方法和js类似 这里只讲一些和js有区别的
// 在比较两个字符串的时候不能直接使用"=="进行比较 如下例子
public abstract class Any {
    public static void main(String[] args) {
        String str1 = "java";
        String str2 = "java";
        String str3 = new String("java");
        System.out.println(str1 == str2);// true
        System.out.println(str1 == str3);// false
        System.out.println(str1.equals(str3));//true
    }
}

用String直接声明一个字符串的时候会在常量池保存字符串，将指针保存在栈中，使用 == 比较的是指针指向的地址而不是具体的值，因此str1 == str2，但是使用new方法构造出的字符串会在堆空间中创建一个String类型的对象，然后str3保存指向这个对象的指针，因此str1 != str3 所以使用 == 比较不可靠

StringBuilder类

由于Java中字符串的不可变性，String声明的变量每一次修改都会在常量池中新增数据，如果频繁修改字符串的话，会产生很多无用数据，引起频繁的垃圾回收。而StringBuilder类产生的字符串产生大量无用的数据**。而在进行字符串拼接的时候，编译器为了进行优化也会默认将String的拼接过程转成StringBuilder类调用append方法来进行。**

public class Any {
    public static void main(String[] args) {
        StringBuilder name = new StringBuilder("hello");
        System.out.println(name.capacity());
        name.append("_").append("world");
        System.out.println(name);
    }
}

Scanner类

接收输入的内容以及一些细节

import java.util.Scanner;

public class Any {
    public static void main(String[] args) {
        // 初始化腰围
        float waistline = 0f;
        // 初始化体重
        float weight = 0f;
        // 声明浮点型参数a，b，bodyFatWeight（脂肪重量）
        float a, b, bodyFatWeight;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的腰围（cm）：");
        if (scanner.hasNextFloat()) {
            waistline = scanner.nextFloat();
        }
        System.out.println("请输入您的体重（kg）：");
        if (scanner.hasNextFloat()) {
            weight = scanner.nextFloat();
        }
        // 计算参数a 公式：参数a = 腰围（cm）× 0.74
        a = waistline * 0.74f;
        // 计算参数b 公式：参数b = 体重（kg）× 0.082 + 44.74
        b = weight * 0.082f + 44.74f;
        // 计算脂肪重量
        bodyFatWeight = a - b;
        // 计算体脂率 =（脂肪重量 ÷ 体重）×100%。
        float result = bodyFatWeight / weight * 100;
        System.out.println("您的体脂率为" + result + "%");
    }
}

异常处理

Java

#Java

Java基础

https://jing-jiu.github.io/jing-jiu/2022/09/05/Java/Java基础/

作者

Jing-Jiu

发布于

2022年9月5日

许可协议

Plugin入门上一篇

Chrome扩展下一篇