java se推荐 java java se

转载

mob6454cc762e37 2023-08-23 07:46:17

文章标签 java se推荐 java System 布尔表达式 文章分类 Java 后端开发

发展史

1990年是sun公司的一个项目，1994年改名为java，现属于oracle公司。

Java版本

javaSE：standard edition,标准版，桌面软件，桌游。
javaME：移动版，发展不怎么好，被Android用了然后带飞了。
javaEE:企业版，一般用其做大型系统，大型网站。

java优点

一次编写，处处运行，在不同系统上安装java虚拟机（JVM）即可使用，且jvm不跨平台，各个系统都可以使用。所以java是跨平台语言。

java相关工具认识

JDK：java development kit ，java开发者工具。（=JRE+运行环境工具）
JRE：java runtime environment， java运行环境，包含 java虚拟机。(只能运行java程序，但不能开发。)（=JVM+核心类库）
JVM：java virtual machine， java虚拟机，相当于在操作系统上模拟了一个cpu去运行java相关的东西。

java跨平台核心是因为JVM

安装jdk（java开发者包）

百度搜索jdk12，找到下载地址
下载对应的版本，下载exe后缀的
双击安装jdk
记住安装的路径，
配置环境变量（不区分大小写）
我的电脑-右键-属性-环境变量

java_home :需要自己新建，写java的jdk的路径。
path ：写到jdk下的bin目录，此条必须写，因为执行程序时会在里面找相应的程序。
classPath: .;java的lib目录（；前写的.代表自己写的类，；后写别人写得类的路径。）

例如： (%包住代表相对应用)

java se推荐 java java se_java

dos下输入 java -version 显示版本表示安装成功

删除jdk

删除java的安装目录（删除jdk的包）
删除java_home（此电脑-属性-高级设置-环境变量）
删除path下关于Java的目录
dos窗口输入 java -version 出现 java 不是内部或者外部命令，也不是可运行的程序或批处理文件

helloworld代码初实现

编译软件编译

public class Hello{
    public static void main(String[] args){
        System.out.print("hello,world");
    }
}

dos窗口编译运行
使用javac编译java文件，会生成一个class文件
再通过java 运行class文件，此时class文件不用写后缀

可能遇到的问题：

-java大小写敏感
-尽量使用英文
-文件名和class后的名字必须保证一致
-符号必须使用英文

java注释

单行注释 //
多行注释/* */
文档注释 /** */ 可以识别的

标识符

又名关键字，是系统定义好的。（所以不能用这些再起名字了）
如 public 、class、 static、 viod、
、标识符是大小写敏感的
可以使用中文命名，但一般不建议这样。
所有标识符都应该以字母A-Z,a-z,美元符$,或者下划线开始。

数据类型

强类型语言: 要求变量的使用要严格符合规定，所有变量必须先定义后才能使用。java、 c++
弱类型语言：变量符合规定就行了，没有这么严格。
java的两大类数据类型：
3.1 基本类型：
数值类型（整数类型（byte、short、int、long）、浮点类型（float（四个字节）、double(占8个字节)）、字符类型（char,占两个字节）），布尔类型（boolean,只占一个位，只有true,false两个取值）
例子： int num1=10;
byte num2=20;
short num3=30;
long num4=30L; //long类型要在数字后面加个L
float num5=50.1F; // 默认为double类型，所以加个F指明为float类型
double num6=3.1415926；
char name=‘张’ ； // 字符类型只能是一个字。或者单个的字母
String names=" ahnasubcnu" //String不是关键字，是一个类。
boolean flag=true;
boolean flag=false;

3.2 引用类型：类、接口、数组

小科普:什么是字节

  1. 位：是计算机 内部数据 存储  的最小单位，11001100是一个八位二进制数。bit
  2. 字节：是计算机中 数据处理 的基本单位，习惯上用B来表示。byte
  3. 1B=8bit (一个字节等于八位数)
  4. 字符：使之计算机中使用的字母、数字、字和符号。
  5. 电脑32位和64位指的是电脑的寻址能力。
  6. 1byte=8bit ； 1024byte=1kb；1024kb=1m；1024m=1G
  7. 1位 只有0和1两种情况，通常以byte为单位（8位）
  8. 1 short = 2 byte; 1 int =4 byte; 1 long =8 byte= 8* 8 =2^64bit
  9. 1 float  =4 byte；1 double =8 byte;
 10. 一个byte有2^8=256个可能性，正负开为[-128,127],即为byte的取值范围。
3.2 **引用类型**：类、接口、数组

///进制问题
1. 二进制：数字前加ob  ob11=2
2. 八进制：数字前加o     o11=9
3. 十六进制：数字前加ox  ox11=16^1+16^0=17  A~F表示10到15

常量、变量

java变量是程序中最基本的存储单位，包括变量名、变量类型和作用域。/数据类型变量名 =值；
声明变量是一条完整的语句，每一个声明必须以分号结束。
变量的分类：

局部变量：只写在方法里面。必须进行初始化。
实例变量：作用域更大，写在类里面，方法的外面，从属于（对象）类，通过类才能使用。如果不自行初始值，默认为0、0.0、false,null.
类变量：和实例变量一样，前面加个static，从属类，static为修饰符，不存在先后顺序

常量：初始化后不能再改变的值，final 常量名=值;常量一般用大写字符。声明一个常量：static final double PI=3.14；（声明一个常量）
变量存在于内存中，程序结束，计算机关机，变量失效，写入磁盘中的东西才能永久保存。
变量的命名规范：

所有变量、方法、类名要见名知意
类成员变量和局部变量：首字母小写和驼峰原则（除了第一个单词以外，后面的单词首字母大写（lastName、monthSalary））
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则Man、DoodMan
方法名：首字母小写和驼峰原则run()、runRun()
即变量名，方法名首字母小写，类名首字母大写都驼峰原则。

运算符

算术运算符：+ - * /(取余) %（取模） ++(自增) --（自减）//自增自减属于一元运算符
赋值运算符：=
关系运算符;> < >= <= ==（等于） !=instanceof //关系运算符返回结果只有（true、false）
逻辑运算符： && || !(与或非 and or !)
位运算符：& | ^ >> << >>>

A= 0011 1100
B= 0000 1101
---------------------
//位运算
A&B 0000 1100     //两个位都为1时，结果才为1
A|B 0011 1101	  //两个位都为0时，结果才为0
A^B 0011 0001     //两个位相同为0，相异为1
~B  1111 0010	  //取反操作
/左移右移相对来说是底层运算，所以效率极高。
<< *2(左移*2)
>> /2(右移/2)
2*8=16  2*2*2*2=16
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3				0000 0101 5
0000 0100 4				0000 0110 6
0000 1000 8				0000 0111 7
0001 0000 16
--------------------------------
//字符串连接符  +
		int a =10;
        int b=20;
        System.out.println(a+b+"");//“”代表空字符串，因为字符串在后面，会先进行计算     30
        System.out.println(""+a+b);//因为字符串在前面，会先进行字符串的拼接            1020
        System.out.println(""+(a+b));//因为加了括号，会优先运算括号里面的。            30

条件运算符：？：(因为涉及三个变量，所以叫三元运算符)

X ? Y : Z//如果X==true,则结果位Y，否则为true;
//x必须是布尔类型的值或者表达式
--------------------
public class demo05 {
    public static void main(String[] args) {
        boolean x= true;
        int y= 2;
        int b =20;
        System.out.println(x ? y : b);
    }
}
---------------------------
public class demo05 {
    public static void main(String[] args) {
         int score =50;
        String type =score<60 ? "不及格":"及格";
        System.out.println(type);
    }
}

扩展赋值运算符：+= 、-= 、*= 、/=

int a=10;
int b=20;
a+=b;//a=a+b
a-=b;//a=a-b

特别说明：短路运算：a&&b ，若a是错误，则不会执行b。

初识math

幂运算2^3

很多运算会使用一些工具类来操作

double pow =Math.pow(2,3);
System.out.println(pow);

包机制

包的本质就是文件夹。
一般用公司域名倒置作为包

JavaDoc

javadoc命令是用来生成自己API文档的。类似与java的API文档

java程序的运行机制

计算机的高级语言编程类型：

编译型：有一个负责翻译的程序，翻译成计算机能看懂的语言。
解释型：对速度要求不高，边执行边解释。
java既属于编译型又属于解释型。java先编译后解释。

程序运行机制：javac中的c就是class的意思，可以把java文件编译成class文件，再通过解释器告诉操作系统进行操作。

用户交互Scanner

说明：实现程序和人的交互，可以通过Scanner类获取用户的输入。通过java.util.Scanner包。

基本语法：
Scanner s = new Scanner(System.in);
Scanner属于类，有两个对象：
//next()不能得到带有空格的字符串，后者可以。
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

package scanner;

import java.util.Scanner;

public class demo03 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);//创建一个Scanner类型的scanner容器，来接收键盘的输入。
        System.out.println("请输入数据：");//提示用户输入数据
        String str =scanner.nextLine();//程序在此时停下，直到输入变量保存到变量类型为String的str中去。
        System.out.println("输出的内容为："+str);//
        scanner.close();
    }

}

顺序结构

java的基本结构就是顺序结构，除非特别指明那个，一般都是一行一行执行。
顺序结构是最简单的算法结构。

选择结构

if单选择结构

if(布尔表达式){
//如果为true执行的语句;
}

if双选择结构

if(布尔表达式){
表达式为true执行的语句;
}else{表达式为true执行的语句;}

if多选择结构

if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else{表达式为true执行的语句;}

package struct;

import java.util.Scanner;

public class ifDemo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        int s = scanner.nextInt();
        if(s==100){
            System.out.println("恭喜，满分");
        } else if(s<100 && s>=90){
            System.out.println("A级");
        } else if(s<90 && s>=80){
            System.out.println("B级");
        } else if(s<80 && s>=70){
            System.out.println("C级");
        } else if(s<70 && s>=60){
            System.out.println("D级");
        } else if(s<60 && s>=0) {
            System.out.println("不及格");
        } else{
            System.out.println("不合法");
        }
        System.out.println("end");
        scanner.close();
    }
}
//按顺序只要一个为真就直接跳出程序。

嵌套的if结构
switch多选择结构

#####switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
switch(表达式){
	case value:
		输出语句;
		break;//可选
	case value:
		输出语句；
		break;//可选
	default:
		//默认输出
}

public class IfDemo03 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        System.out.println("请输入：");
        String s = scanner.nextLine();
        switch(s){
            case "Hello":
                System.out.println("你好");
                break;
            case "100":
                System.out.println("满分");
                break;
            default:
                System.out.println("end");
                break;
        }
        System.out.println("end");
        scanner.close();
    }
    ///break是执行完跳出循环，
    ///default是默认，当都不符合case条件时，执行default语句。
    //break和default都不是必须写的内容。
    //case穿透，不写break会把剩下的case执行输出一遍。所以一般都要配break.

循环结构

while循环

while(布尔表达式){
//循环内容
}
//只要表达式为true，循环就会一直执行，大多数情况下需要一个让表达式失效的方式来结束循环。
//

package struct;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1-100
        int i =0;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}

package struct;

public class WhileDemo02 {
    //计算1+2+3+……+100
    public static void main(String[] args) {
        int i =0;
        int sum =0;
        while(i<100){
            i++;
            sum =sum +i ;
            System.out.println(i+"个数相加的和为："+sum);
        }
        }
    }

do while 循环：即使不满足条件，也至少执行一次。

do{
//代码语句
}whlie(布尔表达式)

package struct;

public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i=100;
        int sum =0;
        do {
            sum = sum + i;
            i++;
        } while(i<100);{
            System.out.printf(i+"个数和和为："+sum);
        }
    }
}

for循环

for循环使一些循环结构变得简单。
for循环是支持迭代的一种通用结构，是最有效最灵活的循环结构。
for循环的执行次数是在执行前就确定的。
for循环说明：
最先执行初始化步骤可以声明一种类型，但可初始化一个或多个循环变量体，也可以是空语句。然后检测布尔表达式，如果为rue，则执行循环体，否则，循环终止，开始执行循环体后面的语句，执行一次循环后，更新循环控制变量，再次检测布尔表达式，循环执行上面的过程。

for(初始化; 布尔表达式; 更新){
//循环体
}
//根据初始值先判断是否满足布尔表达式，若满足则执行循环体，更新控制语句，否则跳出循环。

for( ; ; ){}
//代码可以存在，但是是死循环
。

增强for循环

for(声明语句：表达式)
{
//代码句子
}
//声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型相匹配，其值与数组元素的值相等。
//表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
package struct;
//增强for循环
public class ForDemo06 {
    public static void main(String[] args) {
        int [] number={10,20,30,40,50};//定义了一个数组
        for(int i =0;i<5;i++)
        {
            System.out.println(number[i]);
        }
        System.out.println("=========================");
        for(int x :number ){//增强for循环,遍历数组的元素，直接把number每一项的值赋值给x
            System.out.println(x);
        }
    }
}

break&contine

//break用于强制性退出循环，不执行循环中剩余语句。用在任何循环结构的部分，直接跳出循环。
//coutinue，用于终止某次循环过程。即跳出循环体中尚未执行的部分，接着进行下一次是否执行循环体的判断。

public interface BreakDemo {
    public static void main(String[] args) {
        int i=0;
        while(i<10){
            i++;
            if(i==5)
                continue;//碰到i=5,跳出该次循环，判断是否执行下一次循环。
            System.out.println(i);
        }
        System.out.println("end");
    }
}

public interface BreakDemo {
    public static void main(String[] args) {
        int i=0;
        while(i<10){
            i++;
            if(i==5)
                break;//碰到i=5,跳出循环体
            System.out.println(i);
        }
        System.out.println("end");
    }
}

一些练习：

package struct;
计算0到100之间奇数和偶数的和

public class ForDemo02 {
    public static void main(String[] args) {
        int osum =0;//定义偶数的和
        int jsum =0;//定义奇数的和
        //for(初始化、判断语句、控制语句){循环体//此时用if进行判断}
        for(int i=0;i<=100;i++){
            if(i%2==0){
                osum=osum+i;
            }else{
                jsum=jsum+i;
            }
        }
        System.out.println(osum);
        System.out.println(jsum);
    }
}

package struct;
//用for循环输出1-1000之间能被5整除的数，并且每行输出三个。
public class ForDemo03 {
    public static void main(String[] args) {

        for(int i=1;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");//先找出能被5整除的数字,不让换行输出
            }
            if(i%15==0){
                System.out.println();//找出能被15整除的数，换行出
                //等价于System.out.print("\t");
            }

        }
    }
}```

package struct;
//99乘法表 自己写
public class ForDemo05 {
    public static void main(String[] args) {
        for(int i =1;i<=9;i++){//j代表行，i代表列
            for(int j =1;j<=i;j++){//j代表行，i代表列
                //由行控制列，所以外面是行，里面是列
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
        }
        }
    }
    主要思想：
    1.先打印第一行
    2.我们把固定的1再用循环包起来
    3.去掉重复项，i<j
    4.调整样式

package struct;
//99乘法表

public class ForDemo04 {
    public static void main(String[] args) {
        for(int j = 1; j <= 9; j++){
            for (int i = 1; i <= j; i++) {//i是列，j是行
                System.out.print(i+"*"+j+"="+(j*i)+"\t");
        }
            System.out.println();
        }
        }

    }

//先用一个变量打印出一行或一列，用变量调试。

方法

方法是语句的集合，在一起执行一个功能。本质上就是函数
方法的命名规则：首字母小写，驼峰原则

package method;
public class Demo01 {
    //main方法
    //void代表返回类型为空
    public static void main(String[] args) {
        int sum =add(1,2);
        System.out.println(sum);
    }
    //加法,类的名字为add,类型为int
    public static int add (int a,int b){
        return a+b;
    }

}

设计方法的原则：一个方法只完成一个功能，便于后期的拓展。即原子性。

方法定义及调用

1. 修饰符 返回值类型 方法名（参数类型 参数名）{
2. 方法体
3  .……
4 return 返回值
5. }
方法的定义：
//修饰符：可选，告诉编译器如何调用该方法，定义该方法的访问类型,如public
//返回值类型：方法可能会有返回值，如不需要返回值，关键字为void
//方法名：自己起的名字
//参数：分为实参和形参。多个参数用,隔开
//方法的具体内容。

//方法的调用
对象名.方法名（实参列表）
1.有返回值时调用
2.方法返回值时Void时，方法调用是一条语句。

package method;

public class Demo02 {
    public static void main(String[] args) {
        int max=max(3,4)//方法调用，把方法的值赋值给max
        System.out.println(max);//输出值
    }
    //修饰符       返回值类型 方法名（形参类型 形参名字）
    public static int max(int num1,int num2){
        int result=0;
        if(num1>num2){
            result =num1;
        }if(num1<num2){
            result=num2;
        } else{
            System.out.println("num1<num2");
            return 0;//终止方法

        }        return result;
        }

    }

方法重载

1.方法名一样，但参数列表必须不同（可以是类型不同，个数不同，参数排列顺序不同等），方法的返回值类型可以相同可以不同。仅仅返回类型不同不足以成为方法的重载。（容易出现笔试）
2. 实现理论:

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

可变参数

public static int max(int num1,int num2){//可变参数，max(int num1,double...num2),int为普通参数，double类型的为可变参数，即可以有很多个double类型的参数。
        int result=0;
        if(num1>num2){
            result =num1;
        }if(num1<num2){
            result=num2;
        } else{
            System.out.println("num1<num2");
            return 0;//终止方法

        }        return result;

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在它之前声明。
声明方式：在指定参数类型后加一个省略号

递归

A方法调用A方法。自己调用自己。

package method;
/求阶乘
public class Demo04 {
    public static void main(String[] args) {
        System.out.println(diGui(4));//4的阶乘

    }
    public static int diGui(int n){
        if(n==1){
            return 1;
        }else{
           return n*diGui(n-1);
        }

    }
}

递归会有边界，即一定会进行到底。
先算4->3->2->1 结果在从1返回来
基数比较大大事，占内存效率低，不一定跑起来。会影响机器的性能。

//计算器
public class test {
 
 public static void main(String[] args) {
  try {
   Scanner input = new Scanner(System.in);
   System.out.print("请输入第一个数字：");
   double nuber1 = input.nextDouble();
   System.out.print("请输入第二个数字：");
   double nuber2 = input.nextDouble();
   System.out.print("请输入运算符：（+、-、*、/）");
   String oprate=input.next();
 
   double result = 0;
   switch (oprate) {
   case "+":
    result = nuber1 + nuber2;
    break;
   case "-":
    result = nuber1 - nuber2;
    break;
   case "*":
    result = nuber1 * nuber2;
    break;
   case "/":
    if (nuber2 == 0) {
     System.out.print("除数不能为0");
    } else {
     result = nuber1 / nuber2;
    }
 
    break;
 
   
   }
   System.out.print("结果是：" + result);
  } catch (Exception e) {
   System.out.println("输入有误");
  }
 
 }
 
}
==================================
基本思路
1.写4个方法：加减乘除
2.利用循环+switch进行用户交互
传递需要操作的两个数
输出结果

数组

一组数，相同类型，先后次序，通过下标访问。下标从0开始，数组一旦被创建，大小就不可以改变了。数组中的元素可以是基本类型，也可以是引用类型。

数组的声明与创建

int []  nums;//定义了数组，数组名为nums

nums = new int[10]//  创建一个数组

nums[0]=1; //给数组赋值

声明创建一个数组

int [] nums = new int[10];

///

获取数组长度：array.length

数组使用

package method;

public class ArrayDemo07 {

    public static void main(String[] args) {
        //打印全部的数组元素
        int[] array = {1, 2, 76, 84, 5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
        System.out.println();
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }
        System.out.print(sum);
        System.out.println();
        //查找最大元素
        int max = 0;
        for (int i = 0; i < array.length; i++) {
            if(array[i]>max){
                max=array[i];
            }
        }
        System.out.println(max);
    }
}

package method;

public class ArrayDemo07 {

    public static void main(String[] args) {
    int[] arrays={1,23,45,56,67,78,43};
    printArray(arrays);

    }
    //打印数组元素
    //主要说明数组可以分装成类的参数
    public static void printArray(int[] arrays){
        for(int i=0;i< arrays.length;i++){
            System.out.print(arrays[i]);
        }
        System.out.println("");
    }

多维数组：定义二维数组
int [ ] [ ] array={{1,2,3,4,5},{1,2,3,4,5}}
arrays类
数组中本身没有什么方法，数组中有一个Arrays类，包含操作数组方法的各种元素。例如： array.sort(数组名)会排序，sort是array中的一种方法。
稀疏数组（了解概念即可，不怎么用）
冒泡排序：是一种排序算法。每两个进行一次比较。时间复杂度为o(n2).

package method;

import java.util.Arrays;

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

        int[] a = {2, 34, 5, 6, 78, 90, 55, 45, 23, 12};
        int[] sort = sort(a);//将数组a调用我们写的方法。
        System.out.println(Arrays.toString(sort));//将其转化为字符串输出
    }

    //1.比较数组中两个相邻的元素，第一个数比第二个大，则交换顺序
    public static int[] sort(int[] array) {
        //临时变量
        int tem = 0;
        //外层循环，判断要走都少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比较判断两个数，判断出来，交换位置。
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    tem = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tem;

                }
            }
        }
    return array;
    }
}

初始数组为空时，在栈里
给数组分配空间是，在堆里，通过new关键字
数组的三种初始化(赋值)状态：

1.静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1) , new Man(2,2)};
2.动态初始化

int[] a = new int[2]; 
a[0]=1;
a[1]=2;
3.数组的默认初始化

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

数组的使用

For-Each循环

public class Demo09_Array {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //JDK1.5,没有下标
        for (int array : arrays) {
            System.out.println(array);
        }
    }
}
数组作方法入参

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

数组作返回值

public class Demo09_Array {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        int[] reverse = reverse( arrays);
        printArray(reverse);
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int [arrays.length];
        //反转的操作
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

封装

程序设计原则;高内聚低耦合。
将数据封装起来，只暴露给外界接口。
封装主要是针对属性的。在属性前面加关键词 private
把属性用 private修饰
对私有属性的操作通过公共的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;
    }
}

封装的优点
提高程序的安全性，保护数据.
隐藏代码的实现细节
统一接口
系统可维护增加了

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承!
被final修饰的类不能被继承。
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
子类和父类之间,从意义上讲应该具有"is a"的关系.

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

super注意点:

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

Vs this:

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

// 子类维承了父类，就会拥有父类的全部方法!
public class Student extends Person{
    public Student() {
        //隐藏代码:调用了父类的无参构造
        super(); // 调用父类的构造器，必领要在子类构造器的第一一行
        System.out.println("Student无参执行了");
    }
    public Student(String name) {
        this .name = name ;
    }
    private String name = "qinjiang" ;
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}
public class Person {
    //一个类即使什么都不写，它也会存在个方法
    //显示的定义构造器
    protected String name ="kuangshen";
    int age;
    //alt+ insert
    //1.使inew关键字， 本质是在调用构造器
    //2.用例初始化值
    public Person(){
        System.out.println("Person");
    }
    //有参构造:一旦定义 了有参构造。无参就必须显示定义
    public Person(String name){
        this.name = name ;
    }
    public void print(){
        System.out.println("Person");
    }
}

方法重写

父类静态方法

public class Demo04_A extends Demo04_B{
    public static void test(){
        System.out.println("A==>test()");
    }
}
//重写都是方法的重写，和属性无关
public class Demo04_B {
    public static void test(){
        System.out.println("B==>test()");
    }
}
public 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()
    }
}

父类非静态方法

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()
    }
}
//重写都是方法的重写，和属性无关
public class Demo04_B {
    public void test(){
        System.out.println("B==>test()");
    }
}
public class Demo04_A extends Demo04_B{
    @Override
    public void test() {
        System.out.println("A==>test()");
    }
}

重写:需要有继承关系，子类重写父类的方法!

方法名必须相同
参数列表列表必须相同
修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!

为什么需要重写:

父类的功能，子类不一定需要，或者不一定满足!
Alt +Insert ;---->override;

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件

有继承关系
子类重写父类方法
父类引用指向子类对象
注意:多态是方法的多态，属性没有多态性。

多态注意事项:

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常! ClassCastException!
存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
不能进行多态的方法：
static 方法，属于类，它不属于实例
final常量;
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) {
        //类型之间的转化:父子
        //高               低
        Person obj = new Student();
        //student将这个对象转换为Student类型，我们就可以使lstudent类型的方法了!
        ((Student) obj).go();
	}
}

子类转父类

public class Application {
    public static void main(String[] args) {
        //类型之间的转化:父           子
        //子类转换为父类，可能丢失自己的本来的一些方法!
        Student student = new Student();
        student.go();
        Person person = student;
    }
}

多态总结

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

static

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 student = new Student();
        System.out.println("==========");
        Student student2 = new Student( );
    }
}

//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class demo01 {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方;如；果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。

//约束有人帮我们实现~
public abstract class Action {
    //abstract， 抽象方法，只有方法名字，没有方法的实现!
    public abstract void run();
    public void go(){
        System.out.println("Action==>go()");
    }
    //1. 不能new这个抽象类，只能靠子类去实现它;约束!
    //2. 抽象类中可以写普通的方法~
    //3. 抽象方法必须在抽象类中~
    //抽象的抽象:约束~
    //思考题?  new，存在构造器么?
    //存在的意义抽象出来~ 提高开发效率
}
public class A extends Action{
    //必须实现父类的抽象方法，除非其本身也是抽象类
    @Override
    public void run() {
        System.out.println("A==>run()");
    }
}

接口

普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范! 自己无法写方法~专业的约束!约束和实现分离:面对接口编程
接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能.的思想。如果你是天使，则必须能飞。如果你是汽车,则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。
接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
oo的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、 c#等) ，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

public interface UserService {
    //interface定义的关键字，按口都需 要有实现类
    //常量~ pubsic static final,一般不在接口中定义常量
    int AGE = 99;
    //按口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
public interface TimeService {
    void timer();
}

//抽象类: extends~
//类可以实现接口implements 按口
//实现了按口的类，就需要重写接口中的方法~
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

接口总结

方法public abstract
常量public static final
接口不能被实例化_{，接口中没有构造方法}
implements 可以实现多个接口
必须要重写接口中的方法~

内部类

内部类就是在一个类的内部在定义一个类,比如，A类中定义一个B类,那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
成员内部类

public class Outer {
    private int age = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getAge(){
            System.out.println(age);
        }
    }
}
public class Applications {
    public static void main(String[] args) {

        //demo09
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.getAge();
        inner.in();
        outer.out();
    }
}

静态内部类
局部内部类

//局部内部类
    public void method(){
        class Inner1{
            public void in1(){

            }
        }
    }

匿名内部类

异常

实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。
软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception,意思是例外。这些，例外情况，或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
异常发生在程序运行期间,它影响了正常的程序执行流程。
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常:

检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了,这些异常在编译时不能被简单地忽略。
运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
异常体系结构

Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有是常的超类。
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

异常处理框架
public class Demo1 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //假设要捕获多个异常:从小到大!
        try { //try监控区域
            System.out.println(a/b);
        } catch (Error e){ //catch(想要航获的异常类型! )捕获异常
            System.out.println("Error");
        } catch (Exception e){
            System.out.println( "Exception");
        } catch (Throwable t){
            System.out.println("Throwable");
        } finally { //处理普后工作
            System.out.println( "finally");
        }
        //finally可以不要finally,假设IO， 资源，关闭!
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

主动抛出异常

public class Demo02 {
    public static void main(String[] args) {
        try {
           new Demo02().test( 1, 0);
        } catch (ArithmeticException e) {
            e. printStackTrace();
        }
    }
    //假设这方法中，处理不了这个异常。方法上:抛出异常
    public void test(int a,int b) throws ArithmeticException {
        if (b == 0) { //throw
            throw new ArithmeticException(); //主动的抛出异常，一般在方法中使用
        }
        System.out.println(a/b);
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：docker build中命令执行的日志 docker操作日志

下一篇：java spring切面 spring切面和切点

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯