Java语言简介基础组成封装继承多态抽象类内部类接口

Posted security

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java语言简介基础组成封装继承多态抽象类内部类接口相关的知识,希望对你有一定的参考价值。

Java简介

  • Java版本

J2EE (企业版) J2SE(标准版) J2ME(小型版)

  • Java特性

跨平台

  • JVM、JRE、JDK介绍
  1. JVM(Java虚拟机)
    不同平台上装指定版本虚拟机,就能运行Java程序
  2. JRE(Java运行环境)  
    包括JVM和Java程序所需的核心类库
  3. JDK(Java开发程序包)
    包括JRE

       

综上,所以安装JDK就可以了
使用JDK开发的java程序,交给JRE运行
JRE=JVM+类库    
JDK=JRE+java开发工具

  • DOS命令行
  1. dir列出目录    
  2. cd 改变目录    
  3. cd..后退    
  4. cd根目录      
  5. md创建目录    
  6. rd 删除      
  7. del 删除(文件) *通配符
  8. help寻求帮助,可以查用法
  9. Java -version用来在命令行中查看使用的Java版本
  • 环境变量表示方法

%变量名%

  • 临时设置

Path=haha(这个haha是代表任意值) 在当前命令行窗口有效

  • 文件夹选项可以选择不要隐藏扩展名  
  • classpath临时环境变量    

Java语言基础组成

  • 关键字(都是小写, 类名大写)
  • 标识符

数字不能开头,不可以使用关键字(标识符里有-和$符号)

  • 注释

//单行注释    / * 多行注释/   / * * 文档注释/
注释可以嵌套,但多行不能套多行    
javadoc可提取(Java特有)
可以使用注释,进行逐段调试

    

注释的应用:
/ * 需求:练习...思路:
1、...2、...3、...步骤:
1. 用class关键字完成定义;
2. 主函数:固定格式;
3. 输出语句*/

  • 常量与变量

整数、小数、布尔、字符、字符串、null常量

  • 进制  

byte字节=8个二进制位

  • 负数

四个字节表示

  • 变量

变量作用范围(一对{}之间有效)
格式:数据类型 变量名=值;

  • 数据类型
  1. 整数:byte(1位)、short(2位)、int(默认)(4位),long(8位)
  2. 小数:float(4个字节),double(默认)(8个字节)
  3. 字符:char(2个字节,一个中文正好两个字节)
  4. 布尔:boolean(只有True和False)
  • 类型转换
  1. 自动类型转换
  2. 强制类型转换(丢失精度)

字符+数,显示ACSII码
字符类型运算过程(Java底层用Unicode码)

  • 运算符
  1. 类型运算符细节(byte担心存不下,Integer.Max_VALUE(int 型最大值))
  2. 算数运算符
  •  - * / %(取余) +(连接符)
    ++ --(在原来的基础上自加自减1)
  1. 赋值运算符

=、+=、-=、*=、......

注意:+=不等于=......+......(+=在赋值中做了强制转换,=...+....是两步运算)

  1. 比较运算符

运算完结果必须是True或者False
==   !=  >  <  <=  >=

  1. 逻辑运算符
  1. &用于连接两个布尔类型的表达式
  2. &与|或  &运算特点
  3. ^异或:两边相同为假   
  4. !非
  5. &&和&运算结果一样,但过程有点小区别    
  6. &右边始终参与,&&左为假,右不参与
  7. ||左边为真,后边不参与
  1. 位运算符

<<左移  >>右移  >>>无符号右移

        

左移几位就是乘以2的几次方,
右移:以前最高位是啥就拿啥补空位,右移就是该数据除以2的几次幂
无符号右移:右移,高位出现的空位用0补

例子: 两个数互换问题:

  1. 引入第三方变量
  2. a=a+b;    b=a-b;    a=a-b;
  3. a=a^b;    b=a^b;    a=a^b;
  1. 三元运算符

(条件表达式)?表达式1:表达式2;

  • 程序流程控制

顺序结构  选择结构  循环结构

  1. 选择结构
if(条件表达式) 
{    
	执行语句;  
}
if(条件表达式)
{
	执行语句;  
}  
else{  
	执行语句;  
}
if ........
else if...........
else   if........  
else

当if.....else......运算后有具体结果,可以用三元运算符代替

 代码块:局部代码可以定义局部变量周期

          

switch(表达式){  
	case  取值1:
		执行语句;
		break;  
	case  取值2:
		执行语句;
		break;  
	default:
		执行语句;
		break;
}    
//挨着大括号的break可以不用写
  1. 循环结构
while(条件表达式){ 
	执行语句;  
}
do{  
	执行语句;
}while(条件表达式);
for(初始化表达式;循环条件表达式;循环后表达式){
	...
}

其他流程控制语句:continue(继续);break(跳出);

    

  • 函数

       

定义在类中具有特点功能的一段独立小程序
函数也称方法;
可以将代码封装,复用;

重载:(重复载入):在同一个类中,允许存在一个以上的同名函数,只要参数个数或者参数类型不同即可;

  • 数组

同一类型数据的集合,其实就是一个容器

       

当访问到数组中不存在角标时会发生异常

//格式1:
//元素类型【】  数组名=new  元素类型【元素个数或数组长度】;
int【】  arr=new   int【3】;

//格式2:
//元素类型【】  数组名=new  元素类型【】{元素,元素,...};
  • 堆栈

堆特点:存储实体(一堆数据),不能消失;
栈的特点:先进后出

           

栈:引入(指向)堆中的数据  引入(指针)
堆: 垃圾回收机制:自动不定时回收堆中的垃圾

     

内存空间的划分:局部代码块;决定局部变量生命周期

  • 正向遍历,反向遍历(数据结构)
  • 排序(选择排序、冒泡排序、排序位置置换代码提取)

面向对象

三个特征:封装、继承、多态

对象

用Java语言对现实生活中事物描述,通过类的形式体现
对事物描述两方面:

  1. 属性
  2. 行为

对象就是该类事物实实在在个体
引用数据类型参数传递

封装

private私有,只在本类中有效,其他类就算创建对象也访问不到

public       void  函数名(){
	....    
}

      

封装隐藏实现细节、对象属性、仅对外提供公共访问方式
优点:

  1. 安全性;
  2. 便于隔离;
  3. 提高重用性;
    私有仅仅是一种体现形式(封装的)

Java语言中最小的封装体是函数

构造函数

  • 特点
  1. 函数名与类名相同
  2. 不用定义返回值类型
  3. 没有具体返回值

          

  • 作用

给对象初始化;

          

一个类中如果没有定义构造函数,该类中会有一个默认的空参数构造函数

          

  • 一般函数和构造函数区别
  1. 构造函数:对象创建时就会调用与之对应的构造函数初始化
  2. 一般函数:对象创建后,需要时才调用

          

  • 什么时候定义构造函数?

在描述事物时,该事物已存在就具备的一些内容,这些内容都定义在构造函数中;

  • 构造函数细节
  1. 对象改名:p1.setname("小强");
  2. 构造函数加void成一般函数;

this关键字

  • this(当局部变量和成员变量重名时,可以用关键字this区分)

      

this代表对象,当前对象
this就是所在函数所属对象的引用
简单来说,哪个对象调用了所在的函数,this就代表哪个对象

  • 构造函数调用构造函数,用this调用成员

对this的调用必须是构造函数第一个语句,因为初始化动作要先执行

  • 只要在本类中用本类对象,用this

static(静态关键字)

  

静态数据可以被对象调用,类调用

  • 特点
  1. static是一个修饰符,用于修饰成员;
  2. static修饰的成员被所有对象共享;
  3. static优先于对象存在,因为static随着类的加载已经存在;
  4. static修饰的成员多了一种调用方式,可以用类名调用;
  5. static存储共享数据,类中的私有
  • 成员变量(实例变量)和静态变量(类变量)的区别:
  1. 生命周期:
    成员变量随着对象的创建而存在,随着对象的被回收而释放;
    静态变量随着类的加载而存在,随着类的消失而消失;
  2. 调用方式不同:
    成员变量只能被对象调用;
    静态变量可以被对象调用,也可以类名调用;
  3. 别名不同:
    成员变量(实例)
    静态变量(类变量)
  4. 存储位置:
    成员变量在堆中;
    静态变量存在方法区(的静态区)共享数据区;
  • 静态使用注意事项
  1. 静态方法只能访问静态成员(非静态方法可以访问静态成员,也可以访问非静态成员)
  2. 静态方法不可以使用this,super关键字
  3. 主函数是静态的,只能访问静态的;

主函数

public  static  void  main(String[]  args)
  • 主函数特殊之处
  1. 格式是固定的
  2. 被JVM所识别和调用

public:因为权限必须是最大的
static:不需要对象,直接用主函数所属类名调用即可;
void:主函数没有具体返回值;
main:函数名,不是关键字,只是JVM识别的名字
String[] args:主函数参数列表是一个数组类型的参数,而且元素都是字符串类型;

静态什么时候用呢?

  1. 静态变量:
    当分析对象中所具备的成员变量的值是相同的,只要数据在对象中都是不同的,就是对象特有数据,必须存储在对象中;
  2. 静态函数:
    从源代码看,该功能是否需要访问非静态成员变量(可以加,可以不加的时候,最好加上,不浪费内存)
  3. 静态代码块:
    随着类的加载而执行,而且只执行一次 作用:用于给类进行初始化;
  4. 构造函数代码块:
    构造函数具有初始化对象针对性;

             

面向对象(数组工具对象建立)

  • 文档注释:建立一个用于操作数组工具类,其中包含着常见的数组的函数,如最值,排序等
  • 文档能提取的是公有的

设计模式

对问题行之有效的解决办法,其实他是一种思想;

     

继承

好处:

  1. 提高代码复用性;
  2. 让类之间产生关系,给多态提供了前提;
  • 父类
  • 子类

Java中支持单继承,不直接支持多继承,但对C++的多继承进行了改良

  • 单继承:一个子类只能有一个直接复类

  • 多继承:一个子类可以有多个直接父类(Java中不允许,进行了改良)会产生不确定性,不直接支持,因为父类中有相同成员会产生调用的不确定性;

  • Java支持多重继承:C继承B,B继承A

因此出现继承体系:

  1. 查看体系顶层类,了解体系基本功能;
  2. 创建体系最子类对象,完成功能使用。
  • 什么时候定义继承呢?

当类与类之间存在所属关系时候,就定义继承;

  • 在子父类中,成员的特点体现:

1、成员变量;2、成员函数;3、构造函数;

成员变量

当本类的成员和局部变量同名用this区分;
当子父类中的成员变量同名用super区分父类;

this和super用法很相似:
this代表一个本类对象的引用
super代表一个父类空间

子父类中成员函数特点

1. 覆盖:当子父类中出现成员函数一模一样,会运行子类情况,这种现象称为覆盖;  

函数两个特点:

  1. 重载:在同一类中
  2. 覆盖:子类中,覆盖也称为重写;

覆盖注意事项:

  1. 子类方法覆盖父类方法时,子类权限必须大于等于父类权限;
  2. 静态只能覆盖静态,或被静态覆盖;
  • 什么时候覆盖操作?

当对一个类进行子类扩展时,子类需保留父类功能,但要定义子类特有

子父类中的构造函数——子类的实例化过程

  • 在子类构造对象时,发现访问子类构造函数时,父类也运行了;

原因:在子类中构造函数中第一行有一个默认隐式语句,super()

  • 子类的实例化过程:子类中所有构造函数都默认访问父类构造函数
  • 为什么子类继承父类要访问他们的构造函数?

那是因为子类继承父类,获取了父类内容,所以使用父类内容前,先看父类如何对自己内容初始化

注意:super语句必须定义在子类构造函数第一行

一个对象实例化过程

person.p=new person()
  1. JVM会读取指定路径下person.class文件,并加载进内存,并会先加载person父类;
  2. 在堆内存中开辟空间,分配地址;
  3. 并在对象空间中,对对象属性默认初始化;
  4. 调用对应构造函数初始化;
  5. 构造函数中,第一行先调用父类构造函数;
  6. 父类初始化完后,对子类属性初始化;
  7. 在进行子类构造函数特定初始化;
  8. 初始化完毕后,将地址值赋给引用变量;

final关键字:继承的弊端:打破了封装性;

  1. final是一个修饰符,可以修饰类、方法、变量;
  2. final修饰的类不可以被继承;
  3. final修饰的方法不可以被覆盖;
  4. final修饰变量是一个常量,只能赋值一次;
  • 为什么要用final修饰变量,其实在程序中如果数据固定,则直接用就可以?

为了区别;

抽象类

  • 抽象:abstract /抽象关键字/

没有足够的信息描述一个类就是抽象类;

  • 特点
  1. 抽象类:方法只有声明没有实现时,该方法就是抽象方法,抽象方法必须在抽象类中;
  2. 抽象类不能被实例化,因为调用抽象方法没有意义;
  3. 抽象类必须由子类覆盖抽象类方法,否则,子类还是抽象类;
  • 抽象类是构造函数吗?

    

是,用于给子类对象初始化;

  • 抽象类可以不定义抽象方法?

    

可以,但是少见,通常类中有很多方法,但是却没有内容;

  • 抽象类不能和哪些关键字?

    

private、final、static

  • 抽象类和一般类异同点:

   

相同点:
抽象类和一般类都是用来描述事物的,都在内部定义了成员;
不同点:

  1. 一般类有足够信息描述事物;
  2. 一般类不能定义抽象方法;
  3. 一般类可以被实例化;
  • 抽象类是一个父类吗?    

对.

接口

interface() 当抽象类中方法都是抽象时,这时可以将该抽象类用接口、

   

定义接口使用的关键字不是class,是interface

  • 对于接口常见的成员:
  1. 全局变量(public static final)
  2. 抽象方法(public abstract)

由此得出结论,接口成员都是公共的权限

  • 实现

类与类之间是继承关系;类与接口之间是实现关系;

接口不可以实例化,只能由实现了接口的子类并覆盖了接口中所有抽象方法后,才可以实例化;

      

在Java中不直接支持多继承,因为会调用不确定性,所以改良多实现

      一个类中可以实现多接口

class  Test   implements  A,Z   //多实现
  • 细节:
  • 一个类在继承另一个类的同时,还可以实现多个接口
  • 接口出现避免了单继承的局限性
  • 接口与接口之间是继承关系,而且接口可以多继承;
  • 接口的特点

是对外暴露的规则,是程序的功能拓展,可以用来多实现;         

类与接口之间是实现规则,类继承的同时可以实现多个接口,降低耦合性

  • 接口与抽象类区别:

      

相同点:都是不断向上抽取而来;
不同点:

  1. 抽象类需要被继承,接口需要被实现;
  2. 抽象类中可以定义抽象方法和非抽象方法,接口中只可以定义抽象方法;

多态

  • 定义

某一类事物的多种存在形态;

  • 对象的多态性

一个对象对应着不同类型;

多态在代码中体现,父类或接口的引用指向其子类的对象;

  • 多态的好处

提高了代码扩展性,前期定义的代码,可以使用后期的内容;

  • 多态弊端

前期定义的内容不能调用后期子类特有内容;

  • 多态前提
  1. 必须由关心:继承,实现;
  2. 必须要有覆盖;
  • 多态转型
  1. 自动类型提升,但是特有功能无法访问;作用就是限制对特有功能访问;
  2. 向下转型的目的是为了使用子类中的特有语法;
  • 类型转换异常

注意:对于转型,自始至终都是子类对象在做着类型变化;

多态成员:

  1. 成员变量;
  2. 成员函数;
  3. 静态函数;
  • 多态成员变量
  1. 编译时,参考引用型变量所属类中是否有调用的成员变量;有,编译通过,没有,编译失败;
  2. 运行时,参考引用型变量所属类中是否有调用的成员变量;并运行该所属类中的成员变量;
  • 多态成员函数
  1. 参考引用型变量所属类中是否有调用的成员函数,有,编译通过;
  2. 运行时,参考的是对象所属类中是否有调用的成员函数;
  • 静态函数:谁调用显示谁;

其实对静态方法,直接用类名调用即可;

内部类:类定义在类中

  • 访问特点:内部类可以直接访问外部类中成员,包括私有成员;

外部类访问内部类中成员,必须建立内部类对象;

    

一般用于类的设计
分析事物时,发现事物描述中还有事物;

  • 内部类——修饰符
  1. 如果内部类是静态的,相当于一个外部类;
  2. 如果内部类是静态的,成员是静态的;
  3. 如果内部类中定义了静态成员,这个类也是静态类;
  • 为什么内部类能直接访问外部类成员?

      

因为内部类持有外部类引用;

  • 内部类可以放在局部位置上,只能访问局部被final修饰的局部变量;

  • 匿名内部类:就是内部类简写格式:必须有前提,内部类必须继承或实现一个外部类或接口;

其实就是一个匿名子类对象;

//格式:new 父类 or    接口(){子类内容}





















































以上是关于Java语言简介基础组成封装继承多态抽象类内部类接口的主要内容,如果未能解决你的问题,请参考以下文章

面向对象的学习

Java面向对象三大特性 封装 继承 多态

阶段1 语言基础+高级_1-3-Java语言高级_02-继承与多态_第2节 抽象类_9_接口的私有方法定义

深入理解Java面向对象三大特性 封装 继承 多态

Java基础04 Java隐藏和封装类的继承多态

java面试