Java教程

Java基础

本文主要是介绍Java基础,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java基础

1.java中的注释有三种

1.单行注释 //

2.多行注释 /* */

3.文档注释 /** */

/**
*
*/

2.标识符和关键字

image-20220303112237280

image-20220303112254930

3.数据类型讲解

image-20220303112416534

4.数据类型扩展及面试题讲解

image-20220303113203757

image-20220303113238225

转义字符

image-20220303113748303

5.变量、常量、作用域

1.变量

image-20220303114352793

2.作用域

image-20220303114548681

image-20220303115008855

3.常量

image-20220303115212325

image-20220303115233607

4.变量的命名规范

image-20220303115504368

6.基本运算符

image-20220303134540269

image-20220303135227321

image-20220303135458762

7.包机制

image-20220303140257397

8.JAVADoc生成文档

image-20220303140809613

9.java方法

1.方法的重载

类+对象+方法

​ System.out.println();

  • 重载就是在一个类中,有相同的函数名称,但形参不同的函数;

  • 方法的重载规则:

    • 方法名称必须相同;
    • 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
    • 方法的返回类型也可以相同也可以不同
    • 仅仅返回类型不同不足以成为方法的重载
  • 实现原理

    方法名称相同时,汇编器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。

2.可变参数

  • 从JDK1.5开始,Java支持传递同类型的可变参数给一个方法。
  • 在方法声明中,在指定参数类型后加一个省略号(…)。
  • 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。
    public static void printMax(double... numbers){
        if(numbers.length==0){
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        for(int i = 1; i < numbers.length; i++){
            if (numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }


123456789101112131415

3.递归

递归就是:A方法调用A方法,就是自己调用自己。

递归结构包括两个部分:

  • 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。

  • 递归体: 什么时候需要调用自身方法。

public class test {
    public static void main(String[] args) {
        int n = 4;
        System.out.println(fun(n));
    }

    public  static  int fun(int n){
        if (n == 1){
            return 1;
        }else {
            return fun(n-1)*n;
        }
    }
}
输出:24

    
//Java使用栈机制,占用内存较高。

10.数组

1.数组的声明和创建

image-20220303153155850

public class test01 {

    public static void main(String[] args) {
        int[] nums;  //1.声明一个数组
        //或者 int nums[]

        nums = new int[10];   //2.创建一个数组
        //整合一句为    int[] nums = new nums[10];
        //3.给数组元素中赋值
        int sum = 0;
        //获取数组长度  arrays.length
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i+1;
            sum+=nums[i];
        }

        System.out.println("nums:"+nums[5]);
        System.out.println("sum: "+sum);
    }

}

输出:
nums:6
sum: 55


  • 静态初始化
//静态初始化:创建 + 赋值
int[] a = {1,2,3,4,5};
System.out.println("a:"+a[3]);
  • 动态初始化
//动态初始化:包含默认初始化
int[] b = new int[10];
b[0] = 10;

image-20220303153849359

2.数组的使用

//for-each循环
		int[] nums = {1,2,3,4,5};
        //jdk1.5,没有下标
        for(int num : nums){
            System.out.println(num);
        }

//数组作方法入参
public class foreach {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        printArray(nums);
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

//数组作返回值


3.二维数组

  public static void main(String[] args) {

        int[][] arrays = {{1,2},{2,5},{4,3}};
        System.out.println(arrays[0][1]);  //2

        for (int i=0;i<arrays.length;i++){
            for (int j=0;j<arrays[i].length;j++){
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println(" ");
        }
      
      输出:
            1 2  
			2 5  
			4 3 

    }

4.冒泡排序

	import java.util.Arrays;
public class Demo01
{
    //    冒泡排序
    public static void main(String[] args)
    {
        //        1.比较数组中,两个相邻的元素,如果第一个比第二个大,我们就交换他们的位置
        //        2.每一次比较,都会产生一个最大或最小的数字
        //        3.下一轮,则可以少一次排序
        //        4.依次循环,直到结束
        int[] arr = {
            7, 40, 12, 74, 8, 90
        };
        System.out.println(arr.length);
        int[] a = sort(arr);
        System.out.println(Arrays.toString(a));
    }
    public static int[] sort(int[] array)
    {
        //        临时变量
        int temp = 0;
        //        外层循环,判断我们这个要走多少次;
        for(int i = 0; i < array.length; i++)
        {
            boolean flag = false;
            //            内层循环,比较判断两个数,如果第一个数比第二个数大,则交换位置
            for(int j = 0; j < array.length - 1 - i; j++)
            {
                if(array[j] > array[j + 1])
                { //如果第一个数大于第二个数,2>1,第二个数放前,第一个数放后。
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            if(flag == false)
            {
                break;
            }
        }
        return array;
    }
}

5.稀疏数组

  • 当一个数组中大部分元素为0,或者为同一值得数组时,可以使用稀疏数组来保存该数组。

  • 稀疏数组的处理方式是:

    • 记录数组一共有几行几列,有多少不同值;
    • 把具有不同值得元素和行列及值记录在一个小规模数组中,从而缩小程序的规模;

    image-20220303165519726

public class ArrayDemo {

    public static void main(String[] args) {
        // 创建一个二维数组  11*11    0:没有棋子  1:黑棋子  2:白棋子
        int[][] arrays = new int[11][11];
        arrays[1][2]=1;
        arrays[2][3]=2;
        arrays[5][6]=5;
        arrays[7][4]=2;
        arrays[9][3]=8;
        //输出原始的数组
        System.out.println("输出原始的数组:");
        for (int[] array : arrays) {
            for (int anInt : array) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
        System.out.println("==================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays.length; j++) {
                if (arrays[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效的个数:"+sum);

        //创建一个稀疏数组的数组
        int[][]  arrary2 = new int[sum+1][3];
        arrary2[0][0]=arrays.length;
        arrary2[0][1]=arrays.length;
        arrary2[0][2]=sum;

        //遍历二维数组,将非零的值,存放稀疏数组中
        int  count = 0;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays.length; j++) {
              if (arrays[i][j]!=0){
                  count++;
                  arrary2[count][0]=i;
                  arrary2[count][1]=j;
                  arrary2[count][2]=arrays[i][j];
              }
            }
        }
        System.out.println("===================");
        System.out.println("输出稀疏数组:");
        for (int i = 0; i < arrary2.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arrary2[i][j]+" ");
            }
            System.out.println();
        }

        System.out.println("===================");
        System.out.println("还原稀疏数组:");
        //1.读取稀疏数组,十一行十一列
        int[][]  array3 = new int[ arrary2[0][0]][ arrary2[0][1]];
        // 2.给其中的元素还原它的值
        for (int i = 1; i < arrary2.length; i++) {
            array3[arrary2[i][0]][arrary2[i][1]]=arrary2[i][2];
        }

        System.out.println("输出还原的稀疏数组:");
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3.length; j++) {
                System.out.print(array3[i][j]+" ");
            }
            System.out.println();
        }

    }
}


//输出结果:
    
输出原始的数组:
0 0 0 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 
0 0 0 2 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 5 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 2 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 8 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
==================
有效的个数:5
===================
输出稀疏数组:
11 11 5 
1 2 1 
2 3 2 
5 6 5 
7 4 2 
9 3 8 
===================
还原稀疏数组:
输出还原的稀疏数组:
0 0 0 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 
0 0 0 2 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 5 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 2 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 8 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 

11.面向对象

1.什么是面向对象

image-20220303174902409

非静态方法调用

image-20220303175459199

值传递

public class nums {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);   //输出  1

        nums.change(a);
        System.out.println(a);  //输出  1
    }

    public static  void change(int a){
        a=10;
    }
}

引用传递

public class Demo01 {

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);   //输出结果为 : null

        Demo01.change(person);
        System.out.println(person.name);   //输出结果为 : jihu
    }

    public static void change(Person person){
        //person是一个对象:指向的 ----> Person person = new Person();这是一个具体的人,可以改变属性!
        person.name = "jihu";
    }

}

//定义了一个Person类,有一个属性:name
class  Person{
    String name;
}

2.类与对象的创建

image-20220303190417706

3.构造器

  • 类中的构造器也称为构造方法,是在进行创建爱你对象的时候后必须要调用的,并且构造器有以下两个特点:

    1. 必须和类的名字相同
    2. 必须没有返回类型,也不能写void
  • 作用:

    1. new   本质在调用构造方法
    

    2.初始化对象的值

注意点: 定义有参构造之后,如果想使用无参构造,显示的定义一个午餐的构造

image-20220303191354291

4.简单小结类与对象

image-20220303192742128

image-20220303192805673

5.封装

image-20220303193646176

image-20220303193825698

image-20220303193956783

6.继承 (extends)

image-20220303194818481

image-20220303194828798

ctrl+h看类的关系,所有的类都默认的或间接继承Object

7.super详解

image-20220303195713850

image-20220303195815488

super注意点:

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

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

8.方法重写

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

image-20220303200738440

子类重写父类,执行子类方法。

9.多态

image-20220303202246370

image-20220303202435440

image-20220303202536105

多态注意事项:

  1. 多态是方法的多态,属性没有多态

  2. 父类和子类,有联系 类型转换异常!ClassCastException!

  3. 存在条件:继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();

    ​ 不符合多态:static 方法,属于类,不属于实例;final 常量;private方法。

10.instanceof和类型转换

image-20220303203858554

image-20220303203950455

类型转化:父子之间,子类转换为父类,可能丢失自己本来的一些方法!

1.父类引用指向子类的对象;

2.向上转型(子类转父类),

3.向下(父类转子类),强制转换;

4.方便方法的调用,减少重复的代码。

11.static关键字详解

public class Student extends Person {

    private static  int age=1;  //静态的变量
    private double score = 10; //非静态的变量

    public  void  run(){
        System.out.println("run---");
    }
    public static void  go(){
        System.out.println("--go---");
    }

    // 执行顺序: 2
    {
        System.out.println("匿名代码块");
    }
    // 执行顺序: 1     一起动项目就会先执行   而且只执行一次   可以用来赋初始值
    static {
        System.out.println("静态代码块");
    }
    //  3
    public Student() {
        System.out.println("构造方法");
    }
    
      public static void main(String[] args) {

        Student s1 = new Student();
        System.out.println("=======");
        Student s2 = new Student();

        System.out.println(s1.score);
        System.out.println(s1.age);
        System.out.println(Student.age);
       // System.out.println(Student.score); //这样会报错  因为score不是静态的变量

        go();
        new Student().run();
    }

}


输出结果:
    静态代码块
    匿名代码块
	构造方法
	=======
	匿名代码块
	构造方法
	10.0
	1
	1
	--go---
	匿名代码块
	构造方法
	run---
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class test2 {

    public static void main(String[] args) {
        System.out.println(Math.random()); 
        System.out.println(random());  //导入静态包后  就可以省略Math
        System.out.println(PI);

    }
}

12.抽象类

//abstract  抽象类 : 类   extends:  单继承     (接口可以多继承)
public abstract class Action {

    //约束 ~ 有人帮我们实现
    //abstract ,  抽象方法,只有方法名字,没有方法的实现
    public  abstract void doSomething();

    //抽象类的特点
    //1.  不能new这个抽象类,只能靠子类去实现它:约束!
    //2.  抽象类中可以写普通的方法
    //3.  抽象方法必须在抽象类中
    //抽象的抽象:  约束~
}


//抽象类的所有方法,继承了它的子类,都必须要实现它的方法  ~   除非它也是抽象类
public class A  extends Action{

    @Override
    public void doSomething() {

    }
}


13.接口的定义与实现

接口最能体现oop的精髓,对 对象 的抽象。

在Java编程语言中是一个抽象类型,是抽象对象的集合,对象通常以interface关键字来声明。

  • 普通类:只有具体实现

  • 抽象类:具体实现和规范(抽象方法)共存

  • 接口:只有规范,无法自己实现

    约束和实现分离->面向接口编程

接口就是规范,定义一组规则,它的本质是契约,制定好之后大家都要遵守。

/**
 * 用户接口,需要实现类
 * 锻炼抽象的思维
 */
//interface  定义的关键字 ,   接口都需要有实现类
public  interface UserService {
    // 定义的属性默认是静态常量:public static final
    int age = 10;

    // 定义的方法是公共抽象:public abstract
    //接口中所有定义其实都是抽象的
    void add(String str);
    void delete(String str);
    void update(String str);
    void query(String str);
}
public interface TimeService {
    void timer();
}

特性

  • 接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
  • 接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键字。
  • 接口中的方法都是公有的。

实现

/**
 * 抽象类用继承:extends
 * 接口用实现:implements
 * 类可以实现接口,需要现实所有方法!
 * 利用接口实现伪多继承~
 */
// 类 可以实现接口  implements 接口
//实现了接口的类 ,就必须重写接口中的方法     
//利用接口可以实现多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String str) {

    }

    @Override
    public void delete(String str) {

    }

    @Override
    public void update(String str) {

    }

    @Override
    public void query(String str) {

    }

    @Override
    public void timer() {

    }
}

类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。

在实现接口的时候,也要注意一些规则:

  • 一个类只能继承一个类,但是能实现多个接口。
  • 一个接口能继承另一个接口,这和类之间的继承比较相似。

多继承

  • 不允许多继承
  • 接口允许多继承。

接口与类的区别:

  • 接口不能用户实例化对象。
  • 接口没有构造方法。
  • 接口中所有的方法必须是抽象方法。
  • 接口不能包含成员变量,除了static和final变量。
  • 接口不是被类集成,而是被类实现。
  • 接口支持多继承。
  • implements可以实现多个接口
  • 必须要重写接口中的方法

14.N种内部类

image-20220304101309583

public class Out {

    public  int a = 10;
    public  void out(){
        System.out.println("外部类....");
    }
	//成员内部类
    class inner{
        public void inner(){
            System.out.println("内部类....");
        }
    }
    
      // 可以直接使用外部类的属性/方法
   	 public void getOterId(){
        System.out.println("内部类调用外部类属性和方法");
        // 创建成员内部类之前肯定要创建外部类对象
        // 即使id不是静态变量、out不是静态方法,但创建外部类对象时已经存在。
        System.out.println(a);
        out();
    	}

}


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

        Out out = new Out();
        out.out();
        System.out.println(out.a);

        Out.inner inner = out.new inner();
        inner.inner();
    }
}

输出结果为:
    外部类....
	10
	内部类....

12.异常

1.error和exception

Java把异常当做对象来处理,并定义了一个基类Java.lang.Throwable作为所有异常的超类。

Java语言定义了许多异常类在Java.lang标准包中,主要分为Error和Exception两大类。

image-20220304103629154

image-20220304103901232

image-20220304103922370

2.捕获和抛出异常

异常处理五个五个关键字

  • try 、catch、finally、throw、throws
package com.jihu.Demo;

public class Exception  {

    public static void main(String[] args) {

        int a= 1;
        int b= 0;

        //  ctrl + alt + t 快捷键可以快速选择抛的异常
        try {  //try监控区域
            System.out.println(a/b);
        } catch (Error e) {
            System.out.println("error");
        }catch (java.lang.Exception e) {
            System.out.println("Exception");
        }catch (Throwable e) {
            System.out.println("Throwable");
        }
        finally {  //处理善后工作     一般用来 关闭资源  
            System.out.println("finally");
        }


    }
}
输出结果:
    Exception
	finally


//throw  throws

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

        int a= 1;
        int b= 0;
        try {
            new Exception1().test(a,b);
        } catch (ArithmeticException e) {
    //            e.printStackTrace();
            System.out.println("exception");
        }


    }
            // 假设这个方法中,处理不了这个异常。  方法上抛出异常   用throws
    public  void  test(int a,int b) throws ArithmeticException{

        if (b == 0){
            throw new ArithmeticException();  //主动抛出的异常,一般在方法中使用
        }
    }
}

3.自定义异常

image-20220304111053356

自定义异常类

public class CustomException extends Exception {
    // 传递数字
    private int detail;

    public CustomException(int detail) {
        this.detail = detail;
    }

    //toString: 打印异常信息
    @Override
    public String toString() {
        return "CustomException{" + detail + '}';
    }
}


测试方法test抛出异常throw,再通过throws向外抛出

public class Test {
    public static void main(String[] args) {
        try {
            test(11);
        } catch (CustomException e) {
            System.out.println("打印自定义异常信息");
            System.out.println(e);
        }

    }

    static void test(int a) throws CustomException {
        System.out.println("传输一个参数" + a);
        if (a > 10) {
            // 抛出自定义异常
            throw new CustomException(a);
        }
        System.out.println("ok");
    }
}

总结

image-20220304113420643

这篇关于Java基础的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!