JAVA基础——总结

于 2021-08-09 16:02:50 发布
阅读量137 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45721968/article/details/119484356
版权

JAVA 基础——总结

工具：idea

一、输出"hello,world"

System.out.println("hello,world");

在Linux中：sudo gedit hello.java (创建一个名为hello的java 文件）
sudo javac hello（编译java文件）
public class 后面的 类名必须 和 java 文件的名称是一样的
多行注释：选中要注释的地方，CTRL+? 即可

二、标识符和关键字

在这里插入图片描述

三、数据类型

数据类型分为基本数据类型和引用类型；
基本数据类型分为数值类型和boolean类型：
boolean 返回的结果是true和false
数值类型分为整数类型和浮点数类型和字符类型，
整数类型分为byte（1个字节）short（两个字节） int（4个字节）long（8个字节）
浮点类型 float（4个字节） double（8个字节）
字符类型 char（2个字节）
引用数据类型 分为 类、接口和数组。
扩展：
1、进制：
二进制、八进制、十六进制：

		int i1=10;
        int i2=0b10;//(二进制）
        int i3=010;//(八进制）
        int i4=0x10;//(十六进制）
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
     //输出结果：
     10
     2
     8
     16

Integer内置函数
2、强制转换：
但要注意精确度的缺失：

		double i=3.14;
        int a=(int)i;
        System.out.println(i);
        System.out.println(a);
//输出结果：(精度缺失了）
3.14
3

3、转义字符：

四、类型转换：

1、布尔类型不能转换
2、低类型到高类型转换：自动类型转换 ：例如：float——double
3、高类型到低类型转换：强制类型转换（会导致精度缺失，内存溢出）：例如：double——float

五、变量：

局部变量：在主方法main 的里面
实例变量：从属于对象：（跟着对象产生）

Stu stu=new Stu(); 
System.out.println(stu.age);
//变量age的定义是在类中完成的

静态变量：static

public class a1 {
    //实例变量
    int stu=1;
    String name="zy";
    //静态变量
    static double score=90.2;
    public static void main(String[] args) {
        //局部变量 ：只能在方法内部产生，使用
        String study="chinese";
        System.out.println(study);
        a1 a=new a1();//实例变量从属于对象
        System.out.println(a.stu);
        System.out.println(a.name);
        //静态变量（static从属于类，随着类消失）
        System.out.println(score);
    }
}

成员变量的命名：驼峰原则
扩展:
包机制（package）
导入包：import 包名 通配符.*

六、Scanner输入：

用户交互：Scanner 输入：

Scanner对象：

		Scanner in=new Scanner(System.in);//创建一个in对象
        String name=in.next();//输入字符
        System.out.println(name);
        in.close(); //输入流打开后一定要把它关闭掉，免得占用资源空间；
   // 输入：zy          输入：z y				    
   // 输出：zy          输出：z

关于输入用的是next和nextline的区别：
next（）：不能得到带有空格的字符串，当遇到字符串的时候就会自动结束，输出字符串前面的字符
nextline（）：以enter作为结束符，输入一整行的意思，可以获得空白符

输入浮点数：in.nextDouble();
输入整数：in.nextInt();

七、三种结构

1、选择结构：
if（）{} else {}
equal：判断字符串是否相等：

		String s="zy";
        if(s.equals("zy")){
            System.out.println("okk");
        }else {
            System.out.println("noo");
        }
     //输出：okk

equal 和== 的区别：
equal是方法，一般只有实例化对象才会用
在String中，equal比较的是值，但在实例化对象中，比较的是地址值，因为在创建对象的时候，每个对象的地址都是不一样的。
2、循环结构
3、break，continue 同C语言

八、方法：

C里面叫做函数，Java里面叫做方法。
方法分为静态调用方法（static) 和实例调用方法（创建对象使用方法）
方法包含方法头和方法体：
修饰符 返回值类型 方法名（参数类型 参数名）{ 方法体 }

public class A2 {
    //main方法:返回的是空
    public static void main(String[] args) {
        //静态调用方法：static
        int c=add(1,2);
        System.out.println(c);
        //创建一个a2对象，再调用方法
        A2 a2=new A2();
        int d=a2.hex(4,3);
        System.out.println(d);
    }
    //自己定义的方法：
    //加法(static 静态调用）：
    public static int add(int a, int b){
        return a+b;
    }
    //减法（创建对象时使用）
    public int hex(int a,int b){
        return a-b;
    }
}
//输出：
3
1

重要：方法的重载：
在一个类中，有两个方法，类名相同，但是，参数列表是不同的。
参数返回类型可以相同，也可以不相同
实现理论：方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

public class A2 {
    //main方法:返回的是空
    public static void main(String[] args) {
        System.out.println(add(1,2));
        System.out.println(add(1.0,2.0));
    }
    public static int add(int a,int b){
        return a+b;
    }
    //方法重载：和上面的add方法名称相同，参数列表不同，返回的类型也不同
    public static double add(double a,double b){
        return a+b;
    }
}

九、数组：

1、数组的概述：相同数据的有序集合
2、数组的声明和创建：
动态初始化、静态初始化：

//静态初始化和创建
        int[] stu={1,2,3,4,5};
        System.out.println(stu[0]);
        //动态初始化和创建，动态初始化创建了对象，存储在栈中
        int[] st=new int[10];
        st[0]=10;
        System.out.println(st[0]);

3、数组的使用：

public class A2 {
    //main方法:返回的是空
    public static void main(String[] args) {
//        打印全部数组元素
        int[] stu={1,2,3,4,5};
        for(int i=0;i<stu.length;i++){
            System.out.println(stu[i]);
        }

//        计算所有的元素之和
        int sum=0;
        for(int i=0;i<stu.length;i++){
            sum=sum+stu[i];
        }
        System.out.println(sum);

//        查找最大元素：先将第一个元素设为最大元素
        int max=stu[0];
        for(int i=1;i<stu.length;i++){
            if(stu[i]>max){
                max=stu[i];
            }
        }
        System.out.println(max);
    }
}

写一个使得数组反转的方法：

public class A2 {
    //main方法:返回的是空
    public static  void reverse(int[] array){
        int[] result=new int[array.length];
        int j=0;
        for(int i=array.length-1;i>=0;i--){
            result[j]=array[i];
            j++;
        }
        //输出反转后的数组：
        for(int i=0;i<result.length;i++){
            System.out.print(result[i]+" ");
        }
    }
    public static void main(String[] args) {
        int[] a={1,2,3,4};
        reverse(a);
    }
}

4、多维数组：
这里以二维数组举例：

		int[][] array={{1,2},{3,4},{5,6}};//三行两列的二维数组
        System.out.println(array[0][0]);//输出第一一行第一列；
        int[][] a=new int[10][10];

5、Arrays类
Arrays类是一个数组操作类，位于 java.util 包中
简单的操作：数组的排序（sort）填充（fill）比较是否相等（equals），都是在原数组的基础上进行操作的，即不返回新数组

import java.util.Arrays;

public class A2 {
    //首先创建一个output方法，方便数组的输出：
    public static void output(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] s={5,4,3,2,1};
        int[] s1=new int[5];
        //利用Arrays对象对数组进行排序；（改变原数组）
        Arrays.sort(s);
        output(s);
        //对空数组进行填充；
        Arrays.fill(s1,2);
        output(s1);
        //比较数组元素是否相等；equals
        boolean a=Arrays.equals(s,s1);
        System.out.println(a);
        //打印数组Array.toString
        System.out.println(Arrays.toString(s));
        //输出：[1, 2, 3, 4, 5]
    }
}

十、面向对象编程

1、初识面向对象：
面向对象的本质就是：以类的方式组织代码，以对象的方式封装数据。
对于方法调用的扩展：

2、对象的创建和分析：对象是类的一个实例
先有类，后有对象：使用new来创建：
3、方法的静态调用和动态调用的区别：
静态调用方法的关键词是static：在方法创建之初就已经在内存中存在了
动态调用方法时：要先new一个对象，用对象来实例化类，利用对象来调用类里面的方法，这里方法是没有static关键字的。

public class A3 {
    //关键词的解释：public ：公共的，所有人都可以访问
    public static void Hello(){ 
        System.out.println("hello,world");
    }
    public static void main(String[] args) {
        Student stu=new Student(); //非静态调用
        stu.say();

    }
}
class Student{
    public void say(){
        A3.Hello(); //调用另一个类中的静态调用方法：类名.方法
        System.out.println("i want to study");
    }
}

4、实际参数和形式参数的区别： 关于方法和实例
Java实际上是值传递！

5、类和对象的区别：
类是一种抽象的数据类型，它是对某一类事物整体描述、定义，但是并不能代表某一具体事物。例如 学生类，教师类，电脑类等。
对象 是抽象概念的实例化，张三是对学生的实例化。

类相当于一个模板，对象相当于对模板的具体实例化。

6、关于创建具体的类：

public class A3 {
    public static void main(String[] args) {
        //创建一个sun对象；
        Student sun=new Student();
        sun.name="sun";
        sun.study();
        //创建一个zhang对象;
        Student zhang=new Student();
        zhang.name="zhang";
        zhang.study();

    }
}
//定义一个学生类；
class Student{
    //属性：字段
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(name+" is studying");
    }
}

7、构造器：
关于构造器的快捷键：alt+insert
即使一个类什么也不写，它也存在一个方法，默认的是无参构造器（不用自己写，类中自带）
但是我们一般用的是有参构造器，用来实例化对象

public class A3 {
    public static void main(String[] args) {
        Person person=new Person("li");
        System.out.println(person.name);
    }
}
class Person{
    String name;
    //一个类即使什么都不写，都存在一个方法：构造器；
    //构造器方法：名称必须和类名相同；必须没有返回类型，也不能只写void
    //无参构造器：实例化初始值
    public Person(){
        this.name="sun";
    }

    //有参构造;如果是有参构造的话，就必须在创建对象的时候传入参数
    public Person(String name){ //传入参数,this.name代表的是类里面的参数；
        this.name=name;
    }
}
//输出结果：li

关于创建对象时的内存分析：栈放变量名和mian 方法，堆放置具体的对象，如果从外部传入参数的话，就会自动覆盖刚开始创建对象时的默认初始化参数。
在这里插入图片描述
8、面向对象的三大特性：封装，继承，多态
1）封装：高内聚，低耦合
1）主要是在非主类中使用private来修饰属性，使得主类无法直接访问这些私有属性。
2）提供一些操作（get set）来使得主类来设置和获得属性值

public class A4 {
    //创建一个学生类
    public static void main(String[] args) {
        Student stu=new Student();
        //stu.name; 这里是访问不了的！
        stu.setName("qiqi"); //首先设置name 的名称
        System.out.println(stu.getName()); //得到结果
    }
}
class Student{
    //利用private使得属性私有，使得在主类中无法访问这些私有属性
    //提供一些可以操作这些属性的公共方法;
    private String name;
    private int age;
    private char sex;
    public String getName(){ //创建公共方法来获得名称
        return this.name;
    }
    public void setName(String name){ //创建公共方法来修改属性值（name）
        this.name=name;
    }
}

2）继承：
extends:子类是对父类的扩展：
子类能够继承所有父类的方法：
关于继承中父类的参数，子类的参数和外部传入的参数：

public class Main {
    public static void main(String[] args) {
        Student stu=new Student(); //这里是无参构造，默认的构造器
        //没有用封装的思想，代码有些不严谨
        stu.Hello("张三");
    }
}
class Person{
    String name="zhangsan";
    int age;
    char sex;
}
class Student extends Person {
    String name="zs";
    public void Hello(String name) {
        System.out.println("hello,i am " + name); //从外部传入的参数
        System.out.println("hello,i am " + this.name); //这个子类中的参数
        System.out.println("hello,i am " + super.name);//父类中的name参数利用super来传递
    }
}

关于super的注意点：
1、super调用父类的构造方法，必须在构造方法中的第一个；
2、super必须只能出现在子类方法或者构造方法中;
3、super和this不能同时调用构造方法；

和this进行对比：
1】代表的对象不同：
this:本身调用者的这个对象
super：代表父类对象的调用
2】前提：
this：没有继承也可以调用；
super：只能在继承的条件下调用；
3】构造方法：
this（）：本类的构造
super（）：父类的构造

方法的重写：
子类可继承父类中的方法，但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写
方法重写又称方法覆盖
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

public class Main {
    public static void main(String[] args) {
        Student stu=new Student(); //这里是无参构造，默认的构造器
        //没有用封装的思想，代码有些不严谨
        stu.Hello();
    }
}
class Person{
    public void Hello(){
        System.out.println("hello");
    }

}
class Student extends Person {
    String name="zs";
    
    @Override
    public void Hello() {
//        super.Hello(); //调用父类的方法
        System.out.println("hello,i am " + this.name); //这个子类中的参数
    }
}

方法名必须相同，方法体可以不同。
3）多态：
instance of：返回类型是布尔类型
static:可以扩大使用范围。

9、抽象类和接口：
抽象类：用abstract来修饰：abstract：抽象方法：只有方法的名字，没有方法的实现。
抽象类代码示例：模拟动物模拟器：
首先定义一个抽象动物类：编写抽象方法；
接着 定义动物类的子类：狗类和猫类；
接着 定义一个动物模拟器类：Sim 里面设置一个方法：发出声音（playSound），注意参数是动物类
最后是用户程序Application

//编写抽象类
abstract class Animal{
    //抽象类中的抽象方法
    abstract void getAnimal();
    abstract void cry();
}
//编写狗类继承动物类
class Dog extends Animal{
    //里面的具体方法需要重写
    @Override
    void getAnimal() {
        System.out.println("dog");
    }

    @Override
    void cry() {
        System.out.println("wangwang");
    }
}
class Cat extends Animal{
    @Override
    void getAnimal() {
        System.out.println("cat");
    }

    @Override
    void cry() {
        System.out.println("miaomiao");
    }
}
//编写模拟器类
class Sim{
    //模拟器的作用是：传入的是动物类
    void playSound(Animal animal){
        animal.getAnimal();
        animal.cry();
    }
}

//编写主类：用户程序
public class Application {
    public static void main(String[] args) {
        Sim sim=new Sim(); //创建模拟器的类
        sim.playSound(new Cat()); //创建dog类
        sim.playSound(new Dog()); //创建cat类
    }
}

1】父类是抽象类的话，抽象类中的所有方法，子类都必须去实现：
2】在main中，抽象类是不能被new出来的，只能靠子类去实现它。
3】抽象方法必须在抽象类中，
接口：interface
接口就是规范，定义的一组规则，接口的本质是契约

//利用接口做参数，写个计算器，能完成加减乘除运算。

//首先定义一个计算机接口
interface Computer{
    //定义一个方法；
    int computer(int a,int b);
}
//在Computer接口的加方法
class Add implements Computer{
    public int computer(int a,int b){
        return a+b;
    }
}
//接口下的减方法
class Mul implements Computer{
    public int computer(int a,int b){
        return a-b;
    }
}
//定义使用computer接口的方法：
class useComputer{
    void use(Computer com,int a,int b){
        System.out.println(com.computer(a,b)); //调用computer方法
    }
}
public class Test {
    public static void main(String[] args) {
        useComputer u=new useComputer();
        u.use(new Add(),1,2);
        u.use(new Mul(),3,2);
    }
}

补充：关于接口和继承的区别：
见 七号座先生：基础之继承和接口的区别

o_range124
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值