Java

面向对象编程基础

1. 简介

1.1面向对象和面向过程的区别

面向过程：从解决问题的每个步骤入手，适用于解决比较小的简单问题

程序=算法+数据

面向对象：按照现实世界的特点来管理复杂的事物，把他们抽象成一个对象，具有自己的状态和行为，通过消息的反应来完成一定的任务

程序=对象+消息

1.2类与对象

类：对一组具有相同特性的同类事物的抽象描述，这些对象都是这个类的实例

类相当于是一种数据类型，而对象是该类型的变量，变量的名则是具有某个具体对象的标识

对象：变量和相关方法的集合，其中变量表明了对象的状态，方法表明了对象所具有的行为

面向对象的三个特点：

封装性：将其信息属性和方法实现隐藏起来，只提供调用方法的接口，不关心对对象的行为是如何实现，有利于移植和安全

继承性：将一个已有类中的属性和方法保留，再加上自己特有的属性和方法，子类可以继承父类的行为和属性

多态性：将同名但是有不同的具体实现的多个方法同时存在一个程序中，通过继承和覆盖来实现多态

 1.3实现原理

 Java实现一次编译到处执行

源代码（.java）文件--编译-->字节码文件（.class）---->JVM虚拟机执行

JVM（Java虚拟机）的运行过程

1.代码的装入

由类装载器负责把类文件（.class）加载到Java虚拟机中，在此过程需要校验该类文件是否符合类文件规范

2.代码的校验

字节码校验器检查该类文件的代码中是否存在着某些非法操作

如果字节码校验器检验通过，由java解释器负责把文件解释成机器码执行

3.代码的执行

由解释器完成

1.4JDK和JRE

JDK：java开发工具

 bin:可执行文件

lib:jar包

jre:运行工具

JRE：JVM虚拟机所在位置，执行

1.5配置环境变量

JAVA_HOME:C:/java/jdk1.8;

Path:%JAVA_HOME%\bin;

class path:%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

验证：CMD-->javac

                        set+环境变量名-->检查所配置的环境变量情况

2.基本数据结构和运算符

变量：在程序的执行期间可根据需求经常变化的值

名称：标识符，代表这块内存中的数据

标识符命名：1.数字，字符，下划线构成，数字不能开头

                      2.！，。、#不能用

                     3.区分大小写

                     4.不能用关键字和保留字

类型：根据所存储的数据类型的不同有各种不同类型的变量

初始化：为其赋值或者保留缺省值，变量再使用前必须初始化

作用域：在不同程序块中的可用性及生命周期

2.1Java中两大数据类型

基本数据类型8种：内置类型

数值型：整数类型（byte=1B（字节）,short=2B,int=4B,long=8B）,浮点类型（float=4B单精度类型，double=8B双精度类型）

字符型（char=2B）

布尔型（boolean）只有java有

引用数据类型：根据基本类型扩展的其他类型

类class，接口interface，数组Array

整型转化为字符串：int a=1;

                                str b=a+" ";

2.2运算符

运算符：运算符是一种特殊的符号类型，用以表示数据的运算，赋值和比较，一般由一至三个字符组成

运算符类型：

1.算术运算符：单目运算符：正+ 负-

                        双目运算符 ：+ ,-, *, /，%

2.增量运算符： ++，- -

• ++a //先加1再赋值
• a++ //先赋值再加1
• - -a //先减一再赋值
• a- - //先赋值再减一

3.赋值运算符

=，+=，-=，*=，/=，%=

4.比较运算符

>,<,>=,<=,!=,==

5.逻辑运算符

&  逻辑与

|  逻辑或

^  逻辑异或

!  逻辑非

||  短路或

&& 短路与

&：无论在任何情况，&两边的表达式都会参与运算

&&：当&&左边为false, 则不会计算右边的表达式，只有两个条件都为真时，结果为真，其他情况都为假

||：两个条件都为假时结果为假，其他情况都是真

|，||与&，&&区别一样

6.位操作

逻辑与（&）：对齐的二进制位上下都为1时结果为1，否则为0

逻辑或（|）：对齐的二进制位上下有一个为1结果为1，否则为0

逻辑异或（^）：对齐的二进制位上下不相同时为1时，结果为位1，否则为0

逻辑反（~）:0为1,1为0

补码：正数的补码就是源码

最高位为1 的数为负数，补码针对于负数

 求负数的补码的步骤：-100

1.对负数取绝对值:|-100|=100

00000000 00000000 00000000 01100100

2.逐位取反

11111111 11111111 11111111 10011011

3.再加一

11111111 11111111 11111111 10011100

位移：

   左移<<:向左移动一位相当于乘以二，100<<1=200,100<<2=400

  右移>>:向右移动一位相当于乘、除以二

3.控制语句

3.1条件表达式

3.1.1if 语句

if（条件表达式）

{

}else if（条件表达式）

{

}else{

}

1.条件表达式返回值是boolean

2.if语句是必须的，else if 可以没有，也可以有多个

3.else语句可以没有，最多一个，else语句后面不能有条件表达式

4.if语句可以嵌套

5.如果再if嵌套语句中，else与if语句的配对原则是就近原则

 3.1.2switch语句

switch(表达式){

case 常量1：

　　break;

case 常量2：

　　break;

case 常量3：

　　break;

...

default:

}

1.switch 表达式的返回值必须是整型byte,short,int,char;

2.常量不能重复

3.在switch语句中碰到break语句就终止switch；

4.default语句可以没有，最多一个，与顺序无关，相当于if语句的else;

5.所有的switch语句都可以转换为if语句，但是if语句不一定能转换成switch语句

3.2循环语句

3.1.1 for:一般用于循环次数固定的情况

3.1.2 while：有可能一次都不执行，有可能执行多次

3.1.3do ...while：至少执行依稀，有可能多次

任何循环语句都必须有四种语句：

1.初始化语句；

2.条件判断语句；

3.增量表达式；

4.循环语句块；

例如：9X9乘法表

for(int i=1;i<=9;i++){

　　for(int j=1;j<=i;j++)

　　{

　　　　system.out.print(j+"*"+i+"="+(i*j)+"\t");

　　}

　　system.out.println("");//换行

}

3.类

3.1 类的定义

属性，方法，关系

类是由声明和类体构成

//类

 修饰符 class 类名 extends  {

}

****定义类，类名以大写字母开头，成员变量和函数名称小写字母开头

成员变量：在类的内部函数的外面定义的变量是成员变量

String name;

成员函数：修饰符 返回值 函数名称（）{}

****修饰符：public ，default，protected，private

      返回值：void，数据类型；如果有返回值需在函数中return

      参数(函数的局部变量)：形参：函数定义时的参数

                                            实参：函数调用时的参数     

return：1.结束函数的执行

             2.在函数中可以有多个语句，一般与条件语句结合使用；

             3.无返回值的函数中也可以用return，结束函；

             4.Return可以返回结果，表达式

函数名称符合标识符的命名规则

This：代表当前对象

          当类的成员变量和函数的局部变量同名时，必须加上this关键字进行区分成员变量和局部变量

         变量优先级：当在函数内部有同名的变量存在时，局部变量比成员变量的优先级高

 

3.3对象

对象的声明

Person pl;

对象的实例化：为对象分配存储空间

pl=new Person();

*8种基本数据类型的变量叫变量

引用类型的变量可以叫变量也可以叫对象

3.4构造函数

函数名称与类名同名

函数没返回值，也不能写void关键字，也不能写return语句

特点：

对类进行初始化；

构造函数是由系统自动调用；

构造函数是类中运行的第一个函数

任何一个类一定有一个构造函数，如果没有定义构造函数，系统会自动生成一个默认的构造函数；

构造函数可以重载

3.5类的访问权限

public：所有类

protected：本类，子类（同一个包以及不同包的子类），同一个包的所有类，不同包中的非子类不能访问

default：本类，同一个包的类，不同包中的子类非子类都不能访问

private：只能被本类访问，如果一个类的构造方法是private，则其他类不能生成该类的一个实力

3.6类的封装

将成员变量声明成私有的，再提供一个或者多个公有的方法 实现对该成员变量的访问和修改

类的私有成员变量，成员方法只能在该类内部调用，不能通过该类的对象调用

****

1.将成员变量定义成私有的

2.每个私有变量定义2个共有的的函数

   赋值函数set+变量名称，变量的名称的首字母大写，一般没有返回值，带参

   取值函数get+变量名称，变量的名称的首字母大写，一般有返回值，无参

类封装的目的

隐藏类的实现细节

让使用者只能通过指定的方法访问数据，可以方便加入控制逻辑，限制不合理的操作

便于修改，增强代码的可维护性

可进行数据的检查

3.7内部类

将一个类定义置于另一个类定义中

普通内部类：

1.内部类可以访问外部类的成员变量和成员方法，外部类不能访问内部类的成员变量和成员方法

2.普通内部类中不能定义静态变量和静态方法

Ounter outer = new Ounter()

//使用内部类需要利用外部类的对象

Outer.Inter inter= ounter.new Inter();

3.在外部类中可以定义内部类的对象

4.在函数的内部也可以定义内部类，不太常用

函数或者语句块中的内部类只能访问函数内部的常量和外部类的成员

5.内部类的字节码文件名称：外部类$内部类.class

6.函数内部类名称：外部类$1内部类.class

静态内部类：

1.静态内部类只能访问外部类的静态成员，不能访问实例成员

2.静态内部类可以直接使用,不需要通过外部类的对象来定义内部类

Outer2.Inter2 inter2 = new Outer2.Inter2();

3.静态内部类可以声明静态城管，但非静态内部类不可以

4.修饰符没有任何限制

3.8继承

继承就是面向对象编程的基石，运用继承可以创建一个通用类的定义一系列一般特性，该类可以被更具体的类继承

父类：基类，超类

子类

class 子类 extends 父类{ }

*****

1.私有的成员变量和成员方法不能继承

2.默认的成员变量和成员方法只能被同一个包中的其他类继承,受保护的成员变量和成员方法可以被同一个包中的类和不同包的子类继承

3.不同包的类继承时需要import

4.构造函数不能被继承

5.在运行子类的构造函数之前会先执行父类的构造函数

6.子类的构造函数中如果没有指定调用父类的构造函数，系统会自动调用父类的构造函数

super（）代表父类的构造函数，调用父类调用父类构造函数的语句必须是第一条语句，在执行子类的构造函数之前必须先执行父类的构造函数

super.父类的成员变量--->用于访问父类的成员变量

super.父类的成员函数--->用于访问父类的成员函数

7.继承是是多层单重

父类只有一个，一层一层继承

子类可以有多个

如果一个子类没有extends其他类, 默认继承Object类，Object类是所有类的父类

 

8.如果子类与父类存在同名函数，子类的优先级更高

4.多态

4.1重写override：

1.函数名称与父类的函数名称同名

2.参数列表必须一致

3.返回值相同

4.

 

4.2重载overload：同一类中函数名称相同，参数的个数或者类型不一致

4.3对象类型的转换：

 

1.子类可以自动转换成父类

 

Person p1= new Worker();

p1.test();//执行的是Worker类

2.父类转换成子类必须强制转换

Person p1= new Worker();

Worker worker=（Worker）p1;//person类的对象强制转换成worker类

worker.test();

Student student=(Student) p1// Error, p1的类型是通过worker转换的，不能再转换成Student

3.Final关键字--->固定不变

final类型的常量不能被修改

public static final-->一般常量定义类型

final类型的类 不能被继承

final类型的函数不能被重写

4.instanceof:用来判断变量的类型

//判断p1变量是不是Worker类型的变量

if (p1 instanceof Worker)

{

worker =( Worker)p1;

}

return worker