当前位置: 首页>编程语言>正文

java se推荐 java java se

发展史

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

Java版本

  1. javaSE:standard edition,标准版,桌面软件,桌游。
  2. javaME:移动版,发展不怎么好,被Android用了然后带飞了。
  3. 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开发者包)

  1. 百度搜索jdk12,找到下载地址
  2. 下载对应的版本,下载exe后缀的
  3. 双击安装jdk
  4. 记住安装的路径,
  5. 配置环境变量(不区分大小写)
    我的电脑-右键-属性-环境变量
  1. java_home :需要自己新建,写java的jdk的路径。
  2. path :写到jdk下的bin目录,此条必须写,因为执行程序时会 在里面找相应的程序。
  3. classPath: .;java的lib目录(;前写的.代表自己写的类,;后写别人写得类的路径。)

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

java se推荐 java java se,java se推荐 java java se_布尔表达式,第1张

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

删除jdk

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

helloworld代码初实现

  1. 编译软件编译
public class Hello{
    public static void main(String[] args){
        System.out.print("hello,world");
    }
}
  1. dos窗口编译运行
  2. 使用javac编译java文件,会生成一个class文件
  3. 再通过java 运行class文件,此时class文件不用写后缀

可能遇到的问题:

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

java注释

  1. 单行注释 //
  2. 多行注释/* */
  3. 文档注释 /** */ 可以识别的

标识符

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

数据类型

  1. 强类型语言: 要求变量的使用要严格符合规定,所有变量必须先定义后才能使用。java、 c++
  2. 弱类型语言: 变量符合规定就行了,没有这么严格。
  3. 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

常量、变量

  1. java变量是程序中最基本的存储单位,包括变量名、变量类型和作用域。/数据类型 变量名 =值;
  2. 声明变量是一条完整的语句,每一个声明必须以分号结束。
    变量的分类:
  • 局部变量:只写在方法里面。必须进行初始化。
  • 实例变量:作用域更大,写在类里面,方法的外面,从属于(对象)类,通过类才能使用。如果不自行初始值,默认为0、0.0、false,null.
  • 类变量:和实例变量一样,前面加个static,从属类,static为修饰符,不存在先后顺序
  1. 常量:初始化后不能再改变的值,final 常量名=值;常量一般用大写字符。声明一个常量:static final double PI=3.14;(声明一个常量)
  2. 变量存在于内存中,程序结束,计算机关机,变量失效,写入磁盘中的东西才能永久保存。
  3. 变量的命名规范:
  • 所有变量、方法、类名要见名知意
  • 类成员变量和局部变量:首字母小写和驼峰原则(除了第一个单词以外,后面的单词首字母大写(lastName、monthSalary))
  • 常量:大写字母和下划线:MAX_VALUE
  • 类名:首字母大写和驼峰原则Man、DoodMan
  • 方法名:首字母小写和驼峰原则run()、runRun()
    即变量名,方法名首字母小写,类名首字母大写 都驼峰原则。

运算符

  1. 算术运算符:+ - * /(取余) %(取模) ++(自增) --(自减)//自增自减属于一元运算符
  2. 赋值运算符:=
  3. 关系运算符;> < >= <= ==(等于) !=instanceof //关系运算符返回结果只有(true、false)
  4. 逻辑运算符: && || !(与或非 and or !)
  5. 位运算符:& | ^ >> << >>>
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
  1. 条件运算符: ? :(因为涉及三个变量,所以叫三元运算符)
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);
    }
}
  1. 扩展赋值运算符:+= 、-= 、*= 、/=
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程序的运行机制

  1. 计算机的高级语言编程类型:
  • 编译型:有一个负责翻译的程序,翻译成计算机能看懂的语言。
    解释型:对速度要求不高,边执行边解释。
  • java既属于编译型又属于解释型。java先编译后解释。
  1. 程序运行机制: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();
    }

}

顺序结构

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

选择结构

  1. if单选择结构
if(布尔表达式){
//如果为true执行的语句;
}
  1. if双选择结构
if(布尔表达式){
表达式为true执行的语句;
}else{表达式为true执行的语句;}
  1. 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();
    }
}
//按顺序只要一个为真就直接跳出程序。
  1. 嵌套的if结构
  2. 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.

循环结构

  1. 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);
        }
        }
    }
  1. 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);
        }
    }
}
  1. for循环
  • for循环使一些循环结构变得简单。
  • for循环是支持迭代的一种通用结构,是最有效最灵活的循环结构。
  • for循环的执行次数是在执行前就确定的。
  • for循环说明:
    最先执行初始化步骤可以声明一种类型,但可初始化一个或多个循环变量体,也可以是空语句。然后检测布尔表达式,如果为rue,则执行循环体,否则,循环终止,开始执行循环体后面的语句,执行一次循环后,更新循环控制变量,再次检测布尔表达式,循环执行上面的过程。
for(初始化; 布尔表达式; 更新){
//循环体
}
//根据初始值先判断是否满足布尔表达式,若满足则执行循环体,更新控制语句,否则跳出循环。
for( ; ; ){}
//代码可以存在,但是是死循环
。
  1. 增强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();
        }
        }

    }

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

方法

  1. 方法是语句的集合,在一起执行一个功能。本质上就是函数
  2. 方法的命名规则:首字母小写,驼峰原则
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. 设计方法的原则:一个方法只完成一个功能,便于后期的拓展。即原子性。

方法定义及调用

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;
  1. 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数,任何普通参数必须在它之前声明。
  2. 声明方式: 在指定参数类型后加一个省略号

递归

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);
        }

    }
}
  1. 递归会有边界,即一定会进行到底。
  2. 先算4->3->2->1 结果在从1返回来
  3. 基数比较大大事,占内存效率低,不一定跑起来。会影响机器的性能。
//计算器
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开始,数组一旦被创建,大小就不可以改变了。数组中的元素可以是基本类型,也可以是引用类型。

  1. 数组的声明与创建
int []  nums;//定义了数组,数组名为nums

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

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

声明创建一个数组

int [] nums = new int[10];

///

获取数组长度:array.length
  1. 数组使用
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("");
    }
  1. 多维数组:定义二维数组
    int [ ] [ ] array={{1,2,3,4,5},{1,2,3,4,5}}
  2. arrays类
    数组中本身没有什么方法,数组中有一个Arrays类,包含操作数组方法的各种元素。例如: array.sort(数组名)会排序,sort是array中的一种方法。
  3. 稀疏数组(了解概念即可,不怎么用)
  4. 冒泡排序:是一种排序算法。每两个进行一次比较。时间复杂度为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;
    }
}
  1. 初始数组为空时,在栈里
  2. 给数组分配空间是,在堆里,通过new关键字
  3. 数组的三种初始化(赋值)状态:
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]+" ");
        }
    }
}

封装

  1. 程序设计原则;高内聚低耦合。
  2. 将数据封装起来,只暴露给外界接口。
  3. 封装主要是针对属性的。在属性前面加关键词 private
  4. 把属性用 private修饰
  5. 对私有属性的操作 通过公共的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. extands的意思是“扩展”。子类是父类的扩展。
  3. JAVA中类只有单继承,没有多继承!
  4. 被final修饰的类不能被继承。
  5. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的俩个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
  • 子类和父类之间,从意义上讲应该具有"is a"的关系.
  1. object类
    java中的所有类都直接或间接继承Object类
  2. super
  • super注意点:
  1. super调用 父类的构造方法,必须在构造方法的第一个
  2. super 必须只能出现在子类的方法或者构造方法中!
  3. super和 this 不能同时调用构造方法!
  • Vs this:
  1. 代表的对象不同: this 本身调用者这个对象 super:代表父类对象的应用
  2. 前提 this:没有继承也可以使用 super:只能在继承条件才可以使用
  3. 构造方法 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()");
    }
}
  1. 重写:需要有继承关系,子类重写父类的方法!
  • 方法名必须相同
  • 参数列表列表必须相同
  • 修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
  • 抛出的异常:范围,可以被缩小,但不能扩大: ClassNotFoundException --> Exception(大)
  • 重写,子类的方法和父类必要一 致;方法体不同!
  1. 为什么需要重写:
  • 父类的功能,子类不一定需要, 或者不一定满足!
  • Alt +Insert ;---->override;

多态

  1. 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
  2. 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
  3. 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
  • 注意:多态是方法的多态,属性没有多态性。
  1. 多态注意事项:
  • 多态是方法的多态,属性没有多态
  • 父类和子类,有联系 类型转换异常! ClassCastException!
  • 存在条件: 继承关系,方法需要重写,父类引用指向于类对象! Father f1 = new Son();
  • 不能进行多态的方法:
    static 方法,属于类,它不属于实例
    final常量;
    private 方法;
  1. 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); //不能通过编译
    }
}
  1. 转换
父类转子类

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;
    }
}
  1. 多态总结
  • 父类引用指向子类的对象
  • 把子类转换为父类,向上转型;
  • 把父类转换为子类,向下转型;强制转换
  • 方便方法的调用,减少重复的代码!简介
  • 封装、继承、多态! 抽象类,接口

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);
    }
}

抽象类

  1. abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方;如;果修饰类,那么该类就是抽象类。
  2. 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
  3. 抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
  4. 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
  5. 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。
//约束有人帮我们实现~
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()");
    }
}

接口

  1. 普通类:只有具体实现
  2. 抽象类:具体实现和规范(抽象方法)都有!
  3. 接口:只有规范! 自己无法写方法~专业的约束!约束和实现分离:面对接口编程
  4. 接口就是规范,定义的是一组规则,体现了现实世界中“如果你…则必须能.的思想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你好人,则必须干掉坏人;如果你是坏人,则必须欺负好人。
    接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
    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() {
    }
}
  1. 接口总结
  • 方法public abstract
  • 常量public static final
  • 接口不能被实例化,接口中没有构造方法
  • implements 可以实现多个接口
  • 必须要重写接口中的方法~

内部类

  1. 内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
  2. 成员内部类
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();
    }
}
  1. 静态内部类
  2. 局部内部类
//局部内部类
    public void method(){
        class Inner1{
            public void in1(){

            }
        }
    }
  1. 匿名内部类

异常

  1. 实际工作中,遇到的情况不可能是非常完美的。比如:你写的某个模块,用户输入不一定符合你的要求、你的程序要打开某个文件,这个文件可能不存在或者文件格式不对,你要读取数据库的数据,数据可能是空的等。我们的程序再跑着,内存或硬盘可能满了。等等。
  2. 软件程序在运行过程中,非常可能遇到刚刚提到的这些异常问题,我们叫异常,英文是:Exception,意思是例外。这些,例外情况,或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
  3. 异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
  4. 异常发生在程序运行期间,它影响了正常的程序执行流程。
  5. 要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:
  • 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
  • 运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
  • 错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。
  • 异常体系结构
  1. Java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有是常的超类。
  2. 在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);
    }
}



https://www.xamrdz.com/lan/5pw1967303.html

相关文章: