黑马程序员技术交流社区

标题: java27期技术贴:java的一些基础内容 [打印本页]

作者: wenghaiguang    时间: 2019-5-25 12:31
标题: java27期技术贴:java的一些基础内容
1.JavaEE 企业版  主要从事的工作:企业级别的应用 网站 大数据处理
2.JavaSE 标准版本 GUI
3.JavaME 嵌入式的内容 Android:kotlin

计算机两个最牛的人物: Alan.图灵 计算机的思想(人工智能之父) CPU 计算 流程控制
                                           冯诺依曼  计算机使用二级制 匈牙利 布达佩斯
.class 要执行的话 需要依赖 JVM 即虚拟机进行翻译运行,而在不同的操作系统中,会有不同版本的JVM进行翻译
        windows
        mac
        linux Ubantu CentOS RedHat
       
JRE(Java Runtime Environment)
        JRE是Java程序运行时的环境,其包含了JVM和核心内库;
JDK(Java Development Kit)
        包含JRE和开发工具,开发工具:编译器等
cmd一些命令符的操作和使用:
盘符名称:         切换盘符。
dir:              查看当前目录下的内容
cd:                       打开文件
cd .. :                       返回上一级
cd 文件名/文件名 :多级文件进入
cd\:                           退回到盘符根目录
cls:                           清屏
exit:                           退出
java -version  查看java版本
path环境配置的必要:配置path环境变量后,就能在电脑的任何地方都能运行配置文件(就是让windows默认了知道了该文件),无需打开到该文件的根目录下在进行操作。
下面讲一些java中的一些基础知识的介绍:
关键字特点:系统已经使用定义过的代码
        1.完全小写
        2.有特殊颜色

标识符(自己定义的):
        1.组成:26个大小写英文字母、0-9数字、符号$、下划线_;
        2.不能数字开头;
        3.不能是关键字(即已经被系统定义过的)
        4.两种命名方式:
                                        4.1、大驼峰式:每个单词首字母大写(类名称)
                                        4.2、小驼峰式:首个单词都小写,后面每多个单词首字母大写(变量、方法名称)
                                       
常量(在程序运行期间,固定不变的量):
        分类:
                1.字符串常量:凡是用双引号引起来的部分,叫做字符串常量。列"Hello"、"A";       
                2.整数常量:整数。        列:1、2、3;
                3.浮点数常量:有小数的。 列:2.5、3.14;
                4.字符常量:单引号引起来的部分,只能有且仅有一个字符。 列:'A','9';
                5.布尔常量: true, false;
                6.空常量:null;
               
数据类型:分为1、基本数据类型2、引用数据类型(字符串,数组,类、lamda等)
                        基本数据类型:整数型:byte(2\-127-128 )、short(2\-32000+-32000)、int(4\21Y)默认、long(8\2^63)
                                                  浮点型:float(4\10^38)(单精度)、double(8\10^308)(双精度)默认
                                                  字符型:char(2\65500)
                                                  布尔型:boolean(1\true/false)
                                                  
变量定义(程序运行过程中,会发生变化的量): 数据类型  变量名称 = 数据值;(从右向左赋值,即把右侧的数据值存储到左侧定义的变量名称)
                                                  变量作用域:从定义变量的一行开始,一直到直接所属的大括号结束为止。
                                                                          注意:1.变量使用不能超过其作用域的范围;2.变量不赋值无法使用;
数据类型转换:
        1.自动类型转换:数据范围从小的-->大的,隐性的,编译器自动转换;
        2.强制类型转换:数据范围从大的-->小的,显性的,需要在数据面前加小的类型的数据类型:列:int num=(int)100L;//数据从long-->int, 从大到小;即在100前加小范围数据类型int
        范围小的类型向范围大的类型提升(自动隐性的),byte、short、char运算时直接提升为int;
        1、byte、short、char-->int-->long-->float-->double;2、byte、short、char赋值时,编译器会自动帮忙强制转换为int值;
        强制类型转换时,若超过数据范围,则会数据溢出和精度损失,若数据溢出,则结果为溢出值;

四则运算:
                不同类型的数据类型进行运算时,结果提升为数据类型最大的那种类型。
                字符串类型数据在进行加法运算时,则+号认为连接符号,将两个数据连接起来,注意:字符串数据与任何其他数据相加时,结果均为字符串。
                自增、自减:++,--;
                                        1.单独使用;++前,后++ 结果一样,无区别
                                        2.混合使用;++前,先自增+1后,再与其他运行使用;后++,则先拿原先的值使用后,然后在自增
复合赋值运算符:+= ; -= ; /= ; %= ; *=  -->隐含了一个强制数据转换(编译器帮忙进行)。列 byte i+=5-->i=i+5-->i=(byte)(i+5);
       
比较运算符: >   <  >=  <=  == ;结果为布尔值,即判断表达式是否成立,成立则返回true,否则返回false;       

逻辑运算符:与 && 两边表达式结果都为true,则结果为true,且有短路效果,即为若遇到第一个为false,则后续程序就不执行;
                        或 || 两边表达式结果有一次为true,结果即为true,也具有短路效果,同若遇到的第一个表达式结果为true时,则后续程序不执行;
                        非 ! 结果相反。
                       
三元运算符: 格式:数据类型 变量名称 = 布尔表达式? 表达式A:表达式B;
                         注意事项:表达式A和表达式B的数据类型都能被变量名称接受(保持一致);
流程控制语句:
        顺序结构:从上往下依次执行;
       
        if语句:
                 格式: if(条件判断【结果为布尔值】){
                         满足条件,执行语句体;
                 }else{
                         不满足if条件,执行此大括号的内容;
                 }
                 扩展:if(条件判断){
                         语句体;
                 }else if(条件判断){
                         语句体;
                 }
                 ......
                 else if(条件判断){
                         语句体;
                 }else{
                         语句体;
                 } 备注:从上到下只要满足其中一个条件,则执行该条件下的语句体,其他就不执行;
        switch 语句:
                        格式:
                        switch(表达式){
                                case 常量值1:
                                                        语句体1;
                                                        break;
                                case 常量值2:
                                                        语句体2;
                                                        break;
                                case 常量值13:
                                                        语句体3;
                                                        break;
                                        ........
                                case 常量值n:
                                                        语句体n;
                                                        break;
                                default:
                                                        语句体n+1;
                                                        break;
                        }
                        注意事项:1.switch后面的小括号当中只能是下列数据类型:
                                           基本数据类型:byte、short、char、int;
                                           引用数据类型:String字符串、enum枚举;
                                          2.swithc语句里的case和default顺序位置可以灵活替换;
                                          3.穿透特效,若执行的条件语句体中无break语句时,则会向下穿透,即无视case条件,直接穿透执行语句体,直到遇到break再结束;
                                          4.case后面的常量数值不能重复。
        for 循环的格式:
                        for(①初始化语句[只执行一次];②条件判断;④步进语句){
                               
                                                ③循环体;
                        }       
        while 循环的格式:
                        ①初始化语句
                        while(②条件判断){
                                ③循环体;
                                ④步进语句;
                        }
        do-while 循环格式:特点至少执行一次循环体,即无需判断条件,就先执行一次。
                ①初始化语句;
                do{
                        ②循环体;
                        ③步进语句;
                }while(④条件判断)
        循环次数确定的情况下,使用for循环
        循环次数不确定的情况下,使用while循环
        break语句,跳出循环,结束。
        continue 执行到该语句,会立刻结束当次循环,重新开始下次循环。
        死循环: 格式:
                                while(true){
                                       
                                        循环体;
                                       
                                }
                                扩展(死循环):
                                for(; ; ){
                                       
                                        循环体;
                                       
                                }若条件判断语句为空,则默认为true;
java的内存划分:
        1.栈(Sttack):存放的都是方法中的局部变量;方法的运行一定在栈当中运行;
                                        局部变量:方法的参数,或者是方法{}内部的变量;
                                        作用域:一旦超过作用域,立刻从内存消失。(即变量的作用域特性)
        堆(Heep):凡是new出来的东西,都在堆内存中。
                                堆内存里的东西都有个一个地址值(内存地址哈希值):16进制数据;
                                堆内存里的数据,都有默认值,规则如下:
                                整数:0;
                                浮点数:0.0;
                                字符:'\u0000'(在uncout中字符为4个16进制的0的字符)
                                布尔:false;
                                引用类型:null;
        3.方法区(Method Area)        :存储.class(.java编译后用来运行的字节码文件)相关信息,包含方法的(死)信息(即调用时用的那些,真正方法运行时的具体内容在栈当中运行)。
       
        4.本地方法栈(Native Method Stack):与操作系统相关。
       
        5.寄存器(pc Register):与CPU相关。
       
        数组存放的数据类型:不管是基本类型还是引用类型都能存放到数组里;
        数组的创建格式:
                                动态创建:数据类型 [] 变量名称 = new 数据类型[数组长度];
                                静态创建:数据类型 [] 变量名称 = new 数据类型{具体内容};
                                静态的省略格式: 数据类型[] 变量名称 ={具体内容};
                                动态数组创建时,会在堆中创建一个内存空间,会给予一个一个地址值,并给每个索引对于的空间给予一个默认值(具体内容与堆给予的默认值相同)
                                数组的索引值从0开始到数组长度-1为止。
                                数组长度输出语句:数组名称.length
                                直接输出数组名为输出数组在堆内存中的地址值。               

对象的创建格式及步骤和使用:
                        1.先导入类,即import 创建类所在的那个包的位置:import com.itcast.day0... (包路径).类名称
                          若创建对象和其类所在同一个包内,则不需要导入;
                        2.创建对象 格式:
                                类名称 对象名称 = new 类名称();
                        3.对象使用: 1.对象名称.成员变量 2.对象名称.成员方法。
对象特点: 对象与对象进行赋值时,都是将右侧对象所对应的地址值给了左侧,方法调用时所用的对象参数和返回值对象,同样为地址值传递。
对象的三大特性:1.封装性。 2.继承 3.多态
构造方法:
                格式:
                        public 类名称(参数类型){
                               
                        }
                构造方法是由new语句进行调用的,即在创建对象时new后面类名称时就会调用了一个构造方法。如果没有创建一个构造方法,java编译器在进行编译时,会默认给一个标准的空的构造方法。若自己创建了一个构造方法,则编译器编译的空构造方法则不会在给予。所以在自己进行构造方法编写时,可再编写一个空的构造方法,不然就会无法直接创建无参数的对象。
               
                private 关键字的使用:
                                                        当使用private对变量进行创建时,该成员变量除了在对应
                                                        的.class字节码文件中直接使用,在其他的文件中就不能直接调用,需要用方法间接调用即创建set,get方法进行赋值和调用。
API        (Application Programming interface):用程序编程接口。JDK提供了很多类跟方法,能够直接使用的类叫API。
java.lang包下的内容不需要导包,其他包下的内容都需要import导入。

scanner 类的部分使用:
        先导入包类: import java.util.Scanner。
        构造方法调用: Scanner 对象名称 = new Scanner(System in);备注:该构造方法表示从键盘进行输入。
        成员方法调用: int 类型键盘输入方法: 对象名称.nextInt();【调用后会返回一个从键盘输入的int值,即将键盘输入的数字变成int类型】
                                   String 数据类型键盘输入的成员方法: 对象名称.next();【调用后会返回一个从键盘输入的String值,即将键盘输入的值变成String类型】

匿名对象:
                格式:new 类名称();
                特点:因为匿名对象每次使用都需要直接new 类名称.进行使用,所以他只能有且使用一次,若再次使用则又会创建一个新的匿名对象,所以它可再只用一次对象时使用。
                任何数据都可以做为方法的参数和返回值,匿名对象同样可以做为方法的参数和返回值;
集合:
        类名称ArrayList<E>  --> <E> 为泛型,即为集合中存储元素的统一类型,用字母E进行占位表示,该类型只能为引用类型,不能是基本类型。
        包路径:java.util
        常用的构造方法:无参构造。
        常用的成员方法:
                                        1.集合名称.add(元素值) 全称:public boolean add(E e)备注:向集合当中添加元素,添加的元素必须跟泛型类型相同。该成员方法有一个返回值为:true/false,表示是否添加成功,Arraylist集合来说添加一定成功,返回值可不用,其他集合可能不成功的,就需要用返回值。
                                        2.集合名称.get(索引号)  全称:public E get(int index)备注:即为得到一个集合中对应索引号的元素,跟数组一样从0开始。
                                        3.集合名称.remove(索引号) 全称:public E remove (int index)备注:即会移除一个集合中对应索引号的元素内容,返回值为被移除的内容。
                                        4.集合名称.size();全称:public int size(); 备注:即返回集合的长度(元素的个数跟数组的.length类似)。
集合中如何存储基本数据类型:
                                                使用基本类型数据对应的包装类。即将基本数据类型用对应的引用类型包装类进行包装输出。这些包装类都在java.lang类型下无需导包。
                                                基本类型        包装类
                                                byte                        Byte
                                                short           Short
                                                int                                Integer
                                                long                        Long
                                                float                        Float
                                                double                        Double
                                                char                        Character
                                                boolean                        Boolean
                                       
字符串类:
                字符串对象的创建:
                                无需导包,因为其在java.lang包内
                                创建共3+1种方法:
                                                        1.无参创建:String 对象名称 = new String();创建的字符串内容为空
                                                        2.参数为char 数组类型的创建: String 对象名称=new String(char[] 数组名);
                                                        3.参数为byte 数组类型的创建: String 对象名称=new String(byte [] 数组名);
                                                        +1:直接创建 String 对象名称 = "字符串内容"(该值也为字符串对象)
                字符串类直接创建的对象:即其后直接跟一个""输入内容,该对象的地址值都在字符串常量池中(字符串常量池:是堆内存中特定的一个区域),若直接创建的字符串内容相同,则两个对象创建的地址值会共享一个常量池中的地址。
                若是用构造方法new出来的对象,则地址不在字符串常量池中,是重新创建的地址,即创建两个相同内容字符串的对象地址也会不同。
                两个字符串对象进行比较,==、是比较两个字符串对象的地址值是否相同。
               
                字符串内容比较:
                                        使用public boolean equals(object obj)成员方法进行比较:
                                                格式:字符串对象.equals(比较字符串对象名称),内容相同返回true,不同返回false。
                                                任何对象object 类都能接受
                                                注意事项:若拿常量字符串跟变量进行比较,推荐将常量字符串写写在.号前,即做用变量做为参数对象,不然若给字符串对象赋值null时,调用方法会报空指针异常,即null不能调用方法,但是可以做为参数。
                                                不区分大小写的内容比较方法:public boolean equalsIgnoreCase(object obj)
                                               
                String当中常用方法有:
                                        public int length();获取字符串当中含有的字符个数,拿到字符串长度。
                                        public String concat(String str);拼接字符串,将当前字符串和参数字符串进行拼接返回一个新的字符串。
                                        public char charAt(int index) ;获取索引位置的单个字符。【同样从0开始】;
                                        public int indexOf(String str);获取参数字符串在本字符串中首次出现的位置索引号。若没有返回-1;
                                        public String substring(int index);获取从参数索引位置开始到结束的字符串;
                                        public String substring(int begin ,int end);获取从参数索begin引位置开始到end参数位置结束的字符串;【)
                                        public char[] toCharArray(String str);将字符串拆分为一个char类型的字符数组;
                                        public byte[] getBytes(String str);获得当前字符串的底层字符数组;
                                        public String replace(CharSequence oldString , CharSquence newString);将一个字符串中的所有老字符串替换成为新字符串,返回一个新字符串。
                                        public String[] split(String regex):按照参数的规则将字符串切分成为若干个字符串然后返回一个字符串数组。备注:split方法的参数是一个"正则表达式",今后学习。今天需注意:若要按"."切分字符串,则需要写成"//."
                                       
静态关键字static:被static关键字修饰过的方法还是变量都属于类
                                被static 修饰的成员变量叫静态变量,他是被共享给所有该类创建的对象的。
                                被static修饰过的方法叫静态方法,此类方法调用最好用类名称.方法名进行调用。若用对象名.方法名进行调用也能调用,但是是由编译器帮助修正成类名称。
                                静态不能直接访问非静态。因为在内存中,先有静态内容,然后再有非静态内容,先进入的内容当然无法访问后来的内容,编程的顺序结构。
                                静态方法中不能使用this关键字。
继承性:(共性抽取)
          父类(基类、超类) 子类(派生类)
          定义格式:
                        父类:即正常的类定义: public class 父类名称{} 子类: public class 子类名称 extends 父类名称{}
          子类会继承父类的内容;
          在调用成员变量时,若使用对象调用,则创建对象的类是什么,则优先使用它,没有再向上找。
          在使用成员方法调用变量时,谁调用的方法,就优先使用谁的,没有则向上找。
          在方法中使用变量时(若变量名称都相同):
                                局部变量直接访问。
                                成员变量this.访问。
                                父类变量super.访问。
          成员方法的访问(当父类和子类中都有同名的成员方法时):
                                        谁的对象来访问成员方法,则用该对象对应类的成员方法,没有则向上找父类的,父类不能向下找子类的。
                                       
          方法的重写(覆盖、覆写):
                                                若想子类方法覆盖父类方法:两个方法的名称和参数列表必须相同。即若父类方法的名称和参数列表跟子类的相同就是方法的覆盖。若方法覆盖了就必须满足以下条件:
                                                                1.子类方法的返回值类型范围必须小于或等于父类中覆盖的那个方法;
                                                                小扩展:Object类的范围是所有类中范围最大的类,是公共最高父类(在java.lang包内),列String就是0bject的一个子类;
                                                                2.子类方法的权限修饰符的权限必须大于或等于父类方法;
                                                                小扩展:权限修饰符的权限大小排序:
                                                                                public>protected>(default)此处表示不写,留空即为default>private               
                                                        不满足以上两个条件就会报错。
                                                        Override用处和使用:
                                                                                        可以用来检验是否发生了方法的覆盖,即在方法名称上方写上@Override,无报错即覆盖成功。
                                                                                       
         继承中构造方法的使用:
                                        子类构造方法调用时,编译器会自动在子类构造方法中调用一个父类的构造方法,一般默认为无参构造(类似对象创建时的调用),若父类编写了一个有参构造,子类构造方法中需要自己手动添加访问父类的构造方法才行。且父类的构造方法调用必须在子类构造方法的内的第一条语句。所以有且只能调用一次。
        关键字super的使用:
                                        super.成员变量名称 在父类和子类成员变量名称相同时,用super.变量名称可以访问父类成员变量。
                                        super.成员方法名称 在父类和子类成员方法名称相同时,在子类中可以用super.方法名称来访问父类成员方法。
                                        super(无参/参数); 在子类的构造方法中,可以用super()来访问父类的构造方法。
        关键字this的使用:
                                        this是用来访问本类的内容。
                                        1.this.变量名称。用来访问本类成员变量。
                                        2.this.方法名称 。用来访问本类的成员方法。起到强调是本类的方法作用。
                                        3.this(无参/有参)。跟super类似,是用来调用本类的构造方法的,同样跟super一样必须在该构造方法的第一条语句,
                                        且访问了本类的其他构造方法就不能再调用父类的构造方法了。
       
        继承的特点:
                           1.单继承性。子类有且只能继承一个父类,不能同时继承多个父类。
                           2.多级继承。 一个子类继承父类,它的父类也可以继承一个父类,这样多级继承。
                           3.一个父类可以被多个子类同时继承。
                          
        抽象:
                抽象类:在class前加上abstract关键字即可。
                抽象方法:去掉大括号,且在权限修饰符(public)后加上abstract。列:public abstract void method();备注:抽象方法必须创建在抽象类中;
                抽象类和抽象方法的使用:
                                                抽象类不能直接拿来new 对象,必须先用一个子类来继承抽象类后,通过子类覆盖抽象方法后(覆盖方法正常书写无需写abstract等即方法名称跟参数列表相同即可),进行访问子类覆写方法。子类方法必须覆盖抽象父类所有的抽象方法。
                                                然后创建子类对象进行使用。
                                               
                注意事项:
                                1.抽象类不能直接创建对象。
                                2.抽象类中可以有构造方法,供子类使用,可以用来初始化初始化父类成员。
                                3.抽象类不一定包含抽象方法,但是抽象方法所在的类必须为抽象类。
                                4.抽象类的子类必须重写所有父类的抽象方法,若未重写所有抽象方法,会报错,则也可以修改成为抽象类。
                               
接口:就是多种类的公共规范。
          接口是一种引用数据类型,接口的最重要内容是抽象方法。
          接口的定义格式:
                                        public interface 接口名称{
                                                接口内容。。。
                                        }备注:class-->interface 编译生成的字节码文件任然是.class文件。
          接口中包含的内容:
                                         JDK-7:包含常量、抽象方法。
                                         JDK-8:默认方法、静态方法。
                                         JDK-9:私有方法。
                                         
         接口的使用:(类似抽象类的使用)必须创建一个实现类来实现接口。
                                 格式:
                                         public class 实现类名称 implements 接口名称{};
                                         实现类内必须重写(实现)接口中所有的抽象方法,若未重写所有抽象方法,他必须变成一个抽象类,编译才不会报错。
接口的默认方法:作用为当接口需要在添加抽象方法时,其对应的实现类就需要也再重写其抽象方法,为了避免这个操作,就可以选择添加默认方法进行编写,而其实现类则可以继承对于接口的默认方法,当然也可以重写该默认方法。
        接口中的抽象方法: [public] [abstract] 返回值类型 方法名称();public abstract 可以省略在接口中。
        默认方法格式:
                                [public] default 返回值类型 方法名称(参数/无参){方法体};然后可以通过创建其实现类的对象进行调用,可以在实现类中进行覆写。
        静态方法:
                        格式:
                                [public] static 返回值类型 方法名称(参数列表){方法体};需要用接口名称进行直接调用,不能用实现类创建的对象调用,因为一个实现类可能有多个接口,所以就可能会起冲突。
                               
        私有方法:java9.0以后有。该类方法尽接口自己可以使用。
                        格式:
                        普通私有方法:        private 返回值类型 方法名称(参数列表){方法体};
                        静态私有犯法:  private static 返回值类型 方法名称(参数列表);  
                       
        成员变量:其实就是常量,初始化时必须被赋值,而且赋值后不能在进行修改。格式:
                          [public] [static] [final] 常量名称 = 数组。常量名称推荐格式:每个单词的每个字母都大写, 每个单词之间用下划线连接_;因为是静态的,所以调用时用接口名称调用.
以上即为我现阶段所学习的一些关于java的基础知识,供参考,谢谢大家!               






欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2