Java基础语法03

最新推荐文章于 2024-07-27 13:31:57 发布

不脱发的业内人士

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量218

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_52181177/article/details/117135827

版权

本文详细介绍了Java中的数组，包括定义、声明、初始化和使用，以及多维数组、Arrays类和冒泡排序。接着讲解了面向对象编程的基础，包括类的定义、对象创建、封装、继承、多态，以及Object类、super和this的用法。还探讨了异常处理的基本概念和自定义异常。最后，概述了多线程的概念，线程的创建、生命周期、同步和通信，以及Java注解和反射的基础知识。

摘要由CSDN通过智能技术生成

十一、数组

1、数组的定义

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。

下标从0开始–length-1结束

2、数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

dataType[] A;///数组类型[] 数组名

Java语言使用new操作符来创建数组

dataType[] A = new dataType[数组长度];

数组的元素是通过索引访问的,数组索引从0开始。
1. 获取数组长度：数组名 . length

3、三种初始化

静态初始化

int[] a ={
   1,2,3,4,5};

动态初始化

int[] b =new int[2];
b[0]=1;
b[1]=2;

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

4、数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型,不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组下标越界异常报错： ArrayIndexOutofBounds

5、数组的使用

增强For循环

在这里插入图片描述

数组作为方法的参数
数组作返回值

6、多维数组

int a[行][列] = new int a[2][3];

7、Arrays类

数组的工具类java.util.Arrays

toString()–打印数组元素

sort()–升序排序

在这里插入图片描述

8、冒泡排序

冒泡排序无疑是最为出名的排序算法之一，总共有八大排序!
冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。
我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)。

import java.util.Arrays;
//1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2. 每一次比较，都会产生出一个最大，或者最小的数字;
//3. 下一轮则可以少一次排序!
//4. 依次循环，直到结束!
public class Demo11 {
   
    public static void main(String[] args) {
   
        int[] a = {
   1, 4, 5, 72, 2, 25, 6, 7};
        int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array) {
   
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次;
       	for (int i = 0; i < array.length - 1; i++) {
   
            Boolean flag = false;
            //内层循环，比价判断两个数，如果第一个数，比第二个数大,则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
   
                if (array[j + 1] > array[j]) {
   
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
   
                break;
            }
        }
        return array;
    }
}

9、稀疏数组

十二、面向对象(Object-Oriented Programming, 00P)

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。
抽象
三大特性：
1. 封装
2. 继承
3. 多态

1、类的定义

class 类名{
   //类体
    成员变量
    成员方法
}

2、创建对象与初始化对象

使用new关键字创建对象：使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

类名 对象名 = new 类名();

类中的构造器也称为构造方法(有参构造，无参构造),是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1. 必须和类的名字相同
2. 必须没有返回类型,也不能写void
注意点:定义有参构造之后，如果想使用无参构造，必须显示的定义一个无参构造。

3、封装

该露的露，该藏的藏

我们程序设计要追求**“高内聚，低耦合”**。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。

封装(数据的隐藏)

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。、

记住这句话就够了：属性私有，get/set

//类中只有属性和方法
public class Student {
     
    //类 private: 私有
    //属性私有
    private String name; //名字
    private int id; //学号
    private char sex; //性别
    private int age;
    //提供一些可以操作这个属性的方法!
    //提供——public的get. set方法
    //get获得这个数据
    public String getName(){
     
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
     
        this.name = name;
    }
    //alt + insert
    public int getAge() {
     
        return age;
    }
    public void setAge(int age) {
     
        if(age <0 || age > 120){
     
            this.age = 3;
        }else {
     
            this.age = age;
        }
    }
    public int getId() {
     
        return id;
    }
    public void setId(int id) {
     
        this.id = id;
    }
    public char getSex() {
     
        return sex;
    }
    public void setSex(char sex) {
     
        this.sex = sex;
    }
}

好处：
1. 提高程序的安全性，保护数据.
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了

4、继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承!–一个儿子只能有一个爸爸，一个爸爸可以有多个儿子。
被final修饰的类不能被继承。
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
1. 继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示

class 子类名 extends 父类名{
   
    类体//新添加的新数据域和方法
}

5、Object类

java中的所有类都直接或间接继承Object类。

6、super

super调用父类的构造方法，必须在构造方法的第一个
super 必须只能出现在子类的方法或者构造方法中!
super和 this 不能同时调用构造方法!

7、vs this

代表的对象不同:
this 本身调用者这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this() ; 本类的构造
super():父类的构造!

8、方法重写

父类静态方法

//重写都是方法的重写，和属性无关
public class Demo04_B {
   
    public static void test(){
   
        System.out.println("B==>test()");
    }
}

public class Demo04_A extends Demo04_B{
   
    public static void test(){
   
        System.out.println("A==>test()");
    }
}

ppublic class Applications {
   
    public static void main(String[] args) {
   
        //Demo04
        //方法的调用只和左边，定义的数据类型有关
        Demo04_A a = new Demo04_A();
        a.test();//A==>test()
        //父类引用指向了子类
        Demo04_B b = new Demo04_A();
        b.test();//B==>test()
    }
}

2.父类非静态方法

//重写都是方法的重写，和属性无关
public class Demo04_B {
   
    public void test(){
   
        System.out.println("B==>test()");
    }
}

public class Demo04_A extends Demo04_B{
   
    //Override 重写
    @Override	//注解：有功能的注释！
    public void test() {
   
        System.out.println("A==>test()");
    }
}

public class Applications {
   
    public static void main(String[] args) {
   
        //Demo04
        /*
            静态方法和非静态方法区别很大
            静态方法：方法的调用只和左边，定义的数据类型有关
            非静态方法：重写，父类方法只能是public
         */
        Demo04_A a = new Demo04_A();
        a.test();//A==>test()
        //父类引用指向了子类
        Demo04_B b = new Demo04_A();//子类重写了父类的方法
        b.test();//A==>test()
    }
}

注意：重写:需要有继承关系，子类重写父类的方法!
1. 方法名必须相同
2. 参数列表列表必须相同
3. 修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
4. 抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
5. 重写，子类的方法和父类必要一致;方法体不同!
为什么需要重写:
1. 父类的功能，子类不一定需要，或者不一定满足!
2. Alt +Insert ;---->override;

9、多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件
1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象
4. 注意:多态是方法的多态，属性没有多态性。

public class Person {
   
    public void run(){
   
        System.out.println("Person==>run()");
    }
}

public class Student extends Person{
   
    @Override
    public void run() {
   
        System.out.println("Student==>run()");
    }
    public void stop(){
   
        System.out.println("Student==>stop()");
    }
}

public class Applications {
   
    public static void main(String[] args) {
   
        // 一个对象的实际类型是确定的:new Student();new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
        s2.run(); //子类重写了父类的方法。执行子类的方法 Student==>run()
        s1.run();//Student==>run()
        s1.stop();//Student==>stop()
        Person p1 = new Person();
        p1.run();//Person==>run()
    }
}

多态注意事项:

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常! ClassCastException!
存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
不能进行重写的方法：
1. static 方法，属于类，它不属于实例
2. final常量;
3. private 方法；
instanceof：(类型转换)引用类型，判断一个对象是什么类型。

public class Applications {
     
    public static void main(String[] args) {
     
        Object object = new Student();
        //System. out . println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系
        //System. out . println(X instanceof Y);// X是Y之的子类，true
        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //False
        System.out.println(object instanceof String); //False
        System.out.println("===========================");
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Teacher); //False
        //System.out.println(person instanceof String); //不能通过编译
        System.out.println("===========================");
        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person); //true
        System.out.println(student instanceof Object); //true
        //System.out.println(student instanceof Teacher); //不能通过编译
        //System.out.println(student instanceof String); //不能通过编译
    }
}

转换

子类转父类

public class Application {
       
    public static void main(String[] args) {
       
        //子类转换为父类，可能丢失自己的本来的一些方法!
        Student student = new Student();//自动转换，此时不能通过父类变量去调用子类的某些方法。
        student.go();
        Person person =new student();
    }
}

父类转子类

public class Application {
       
	public static void main(String[] args) {
       
        Person obj = new Student();
        ((Student) obj).go();//强制转换
	}
}

总结
1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型；
3. 把父类转换为子类，向下转型；强制转换
4. 方便方法的调用，减少重复的代码!简洁
5. 封装、继承、多态! 抽象类，接口

10、static

非静态可以调用静态，但是静态不能调用非静态。

  ~~~java
  public class Student {
   
      //2:赋初值~
      {
   
          System.out.println("匿名代码块");
      }
      //1 :只执行一次~
      static {
   
          System.out.println("静态代码块");//先执行静态，静态伴随着类出生
      }
      //3
      public Student() {
   
          System.out.println("构造方法");
      }
      public static void main(String[] args) {
   
          Student student1 = new Student();
          System.out.println("==========");
          Student student2 = new Student();
      }
  }
  ~~~
  
  ~~~java
  //静态导入包~
  import static java.lang.Math.r

最低0.47元/天解锁文章

不脱发的业内人士

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础语法03

十一、数组1、数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。下标从0开始–length-1结束2、数组声明创建首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:dataType[] A;///数组类型[] 数组名Java语言使用new操作符来创建数组dataType[] A = new dataType[数组长度];
复制链接

扫一扫

专栏目录