面向对象认知概述

面向对象思想是人类最自然的一种思考方式，它将所有预处理的问题抽象为对象，同时了解这些对象具有哪些相应的属性及行为，以解决这些对象面临的一些实际问题，面向对象设计实质上就是对现实世界的对象进行建模操作。
面向对象，是一种设计思想。从20世纪60年代提出面向对象的概念到现在，它已经发展成为一种比较成熟的编程思想，其以人类习惯的思维方式，用对象来理解和分析问题，使开发软件的方法与过程尽可能接近人类认识的世界、解决问题的思维方法与过程。如我们经常听说的面向对象编程就是主要针对大型软件设计而提出的，它可以使软件设计更加灵活，并且能更好地进行代码复用。

类与对象的定义

类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。

类与对象的关系

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

Java创建类的语法

pubilc class 类名{
//类的内容
}

1.类名要有直白意义，最好是英文。

2.首字母大写

3.不要数字开头，不要有特殊字符。

面向对象程序设计的特点

封装

将对象的属性和行为封装起来，其载体就是类，类通常会对客户隐藏其实现细节，这就是封装思想，例如使用计算机时，只需要使用手指敲击键盘就可以实现一些功能，无须知道计算机内部是如何工作的。

采用封装的思想保证了类内部数据结构的完整性，使用该类的用户不能轻易地直接操作此数据结构，只能操作类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。

继承

可以说子类的实例都是父类的实例，但不能说父类的实例是子类的实例。继承是实现重复利用的重要手段，子类通过继承，复用父类属性和行为的同时又添加了子类特有的属性和行为。

多态

将父类对象应用于子类的特征就是多态，子类继承父类特征的同时，也具备了自己的特征，并且能够实现不同的的效果，这就是多态化的结构。

面向对象思想

对象泛指现实中的一切事物，每种事物都具备自己的属性和行为。

面向对象思想就是在程序设计中，参照现实事物，将事物的属性和行为抽象出来。

它区别于面向过程思想，强调通过调用对象的行为来实现功能，而不是自己一步步去操作实现。

举例（洗衣服）：

面向过程:脱衣服——放进盆——加洗衣粉——加水——浸泡——搓洗——清洗——拧干——晾起来
面向对象：脱衣服——扔进洗衣机——晾起来

面向过程：强调步骤；面向对象：强调对象，上例中的洗衣机就是对象。

面向对象思想更符合人类的思考习惯，将复杂问题简单化，让人类从执行者变成指挥者。

面向对象三大特征：封装、继承、多态。

介绍类与对象

对象

所谓的对象其实就是通过java类所产生的实体。例如：盖楼房的图纸就是Java类，根据这个图纸修建起来的能够被看见，被使用的这个实际存在的楼房,就是相当于是用过这个图纸得到的对象。Java类实际是一个抽象意义上的概念，对象就是通过这个java类的抽象概念具体化之后的一个具体概念。

对象是一个抽象概念，英文称作“Object”，表示任意存在的事物。通常对象划分为两个部分，即静态部分与动态部分。静态部分被称为属性，例如人的性别，动态部分指的是对象的行为，例如人可以行走。

一些建议和小结
1、通过new + 构造方法就可以得到一个类的对象。因此上一个类中的构造方法就显得很重要，所以我们通过class关键字定义出来的java类，默认就是有一个无参数的构造方法存在，只不过我们没有显式写出这个无参数的构造。当出现有参数的构造方法时，最好能够显式写出这个无参数的构造方法。类中的构造方法就是为了创建对象而存在的。通过new 构造方法就可以得到一个类的对象是一个没有名称的对象，因此上也叫匿名对象。所以通常情况下我们都是需要定义/声明一个该类的变量来保存这个类的对象。我们把保存对象的这个类的变量又叫引用。【引用中实际上保存的是该对象在内存的实际地址】

2、Java语言中的对象是对现实世界中对象的模拟，现实中的对象存在于现实生活中，Java语言中的对象存在于计算机内存中。

Java语言中的对象又称为实例。

3、Java中将现实对象中的信息称为属性(也叫全局变量)，将现实对象中的功能称为方法。

4、通过new关键字创建对象，创建对象又称实例化对象。 Student student = new Student();

使用”.”运算符访问对象的属性和方法。 student.属性 = 值； student.方法名();

举例：一只狗

属性：旺财，黄色，中华田园犬，5公斤；行为：汪汪叫，欢快跑

类

类其实就是一个模板，比如说类就好比一张房子的设计图纸，或者说是一个倒印模具，创建一个类就好比设计一张图纸，刻一个模板。对象就好比一座建好的房子，一个成型的模型，无疑想要一座房子或者一个模型都先需要一张图纸和一个模板，而这就是类和对象的关系。

举例：狗

属性：名字、颜色、品种、体重；行为：叫、跑。

首先Java里面的类由关键字class定义,类中的元素称为：成员属性。类中的函数称为：成员方法。

class Person {//创建类public int age;//成员属性 实例变量public String name;//成员属性 实例变量public String sex;//成员属性 实例变量public void eat() {//成员方法System.out.println("吃饭!");  //输出吃饭!}public void sleep() {//成员方法System.out.println("睡觉!");  //输出睡觉！}
}

如下就是定义一个类

class Person {//创建类public int age;//成员属性 实例变量public String name;//成员属性 实例变量public String sex;//成员属性 实例变量//....人的属性
}

然后拿这个类创建一个对象，然后我们可以通过点号 . 来访问这个对象的成员，看下图

Person person = new Person();//实例化一个对象

运行程序之后，可以看到在没有赋值之前是会默认赋值为类型相对应的0值。

注：这里之所以有默认的0值，是因为他们都是成员变量，不属于局部变量，所以有默认值，局部变量需要自己赋值才能使用。

类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。在Java语言中，类包括对象的属性和行为。类中对象的属性是以成员变量的形式定义的，对象的行为是以方法的形式定义的。

创建类的语法：

pubilc class 类名{

//类的内容

}

注：

类名要有直白意义，最好是英文。

不要数字开头，不要有特殊字符。

一些建议和小结
1.建议实现类的时候将成员变量尽量设置为private属性，防止数据被直接篡改，而方法非必要公开的接口也设置为private属性的，具体根据实际情况来定

2.变量名和方法名使用小驼峰命名规则，尽量做到见名知意，做不到应该给上适当的中文注释，帮助其他人理解代码的意思

3.static修饰的代码和代码块优先于任何代码执行

4.一个类可以创建多个对象，很好理解，一张图纸可以建造多栋相同的房子，比如小区的楼房就是一张图纸建造出来的

5.在实例化一个对象的时候会调用一个构造方法，所谓的构造方法就一个名字与类名相同的方法，可以带参数，没有返回值类型声明，并且如果你没有定义的话，编译器就会自动实现一个不带参数的构造方法，如果你定义了，那么编译器就不会自动生成。并且构造方法也是支持重载的，构造方法的用处之一就是可以在创建对象的时候就进行赋值。

创建类与对象

创建对象的格式为:

对象名1 = 类名()

对象名2 = 类名()

对象名3 = 类名()

类与对象的关系

基本概念
1、类：类是一个模板，它描述一类对象的行为和状态。（比如一张汽车设计图纸）
2、对象：对象表示现实世界中一个具体的事物。对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。（比如根据汽车设计图纸设计出来的汽车）
3、类与对象的关系
（1）类是抽象的概念，仅仅是一个模板，比如说：“人”。
（2）对象是一个你能够看得到、摸得着的具体实体。
（3）类定义了对象将会拥有的特征（属性）和行为（方法）
（4）类是对象的类型，对象是类的实例

类和对象的区别

1，类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
　　2，对象是类的一个具体。它是一个实实在在存在的东西。
　　3，类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
　　4，对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

成员变量
由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

成员变量和类变量的区别：

1、两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象的回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3、别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

4、数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名:静态方式。

3、静态随着类的加载而加载。而且优先于对象存在。

对应的就是事物的属性

和之前定义的变量几乎时一样的，只不过位置发生了改变，成员变量位于类中，任何方法之外。

在Java中对象的属性也称为成员变量，成员变量的定义与普通变量的定义一样。

1、数据类型变量名称 [= 值];

定义变量可以为其赋值，也可以不为其赋值。如果不设置初始值，就会有默认值。

方法的作用
方法名和类名相同，没有返回值和void，没有return，不能被static等关键字修饰，可以方法重载（定义多个参数列表不同的构造方法）

当一个类中没有写构造方法时，系统会默认给该类一个默认的无参构造方法。当自己定义构造方法后默认的构造方法就不存在了。（自己定义有参的构造方法后，如果还想使用无参的构造方法，就要自己再添加一个无参的构造方法）

普通顺序结构：

public class MethodSample01 {public static void main(String[] args){int a =10;if(a % 2 == 0){System.out.println(a +"是偶数");}else{System.out.println(a +"是奇数");}int b = 5;if(b % 2 == 0){System.out.println(b +"是偶数");}else{System.out.println(b +"是奇数");}
}定义方法，并调用方法： public class MethodSample01 {public String isOddNumber(int num){if(num &2 == 0){return "偶数";}else{return "奇数";}}public static void main(String[] args) {int a = 10;MethodSample01 methodSample01=newMethodSample01();Stringr1=methodSampile01isOddNumber(a);System.out.println(a +"是"+ r1);int b = 5:Stringr2=methodSample01.isOddNumber(b);System.out.println(b+"是"+r2);}
}

运行结果如下：

成员方法

成员方法对应于类对象的行为，他主要用来定义类可执行的操作。

权限修饰符返回值类型方法名 (参数类型参数名){
return 返回值;
}

定义方法时如果没有指定权限修饰符，方法的默认访问权限为缺省（即只能在本类及同一个包中的类中进行访问）

成员方法的参数

调用方法时可以给该方法传递一个或多个值，传给方法的值叫做实参，在方法内部接受实参的变量的叫做形参。形参只在方法内部有效，Java中方法的参数主要有3种，分别为值参数、引用参数和不定长参数。

成员方法是不带static的，但是为了测试，所以方法都带了static。

值参数

值参数表名实参与形参之间按值传递，当时用值参数的方法被调用时，编译器会为形参分配存储单元，然后将对应的实参的值复制到形参中，由于是值类型的传递，所以在方法中对值类型的形参修改并不会影响到实参。

面向对象特性之封装

包-Package
Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。定义包语法格式如下：

package 包名;

Java 包的命名规则如下：

1.包名全部由小写字母（多个单词也全部小写）。

2.如果包名包含多个层次，每个层次用“.”分割。

3.包名一般由倒置的域名开头，比如 com.baidu，不要有 www。

4.自定义包不能 java 开头。

注意：如果在源文件中没有定义包，那么类、接口、枚举和注释类型文件将会被放进一个无名的包中，也称为默认包。在实际企业开发中，通常不会把类定义在默认包下。

package com.micheal.test
public class Test {
}

java解释器会将package中的.解释为目录分隔符/，也就是说该文件的目录结构为：...com/micheal/test/Test.java
那么package中的类的访问权限是怎么样的呢？在同一package中的类是可以互相访问的，比如：

//Test1.java
package test;
class Test1 {}
//Test2.java
package test;
public class Test2 {
public static void main(String[] args) {
Test1 t;
}
}

由于Test2与Test1在同一个package—test中，所以Test2能够直接调用Test1生成Test1的引用变量t；在命令行进行编译时，直接编译Test2.java即可：javac Test2.java（若没有进入Test1和Test2的目录，需在Test2前加上绝对路径）
若类在不同的package中，那么在一个类中要调用另一个package中的类（必须是public类，非public类不支持不同包间访问），需要在类名前明确加上package名称；不过，java中存在一个让java程序员偷懒的特性，叫做import关键字。使用import就可以在一个package中导入另一个package中的类，不过import和C语言和C++中的#include是不同的，import并不会在当前java文件中嵌入另一个package中的类的代码，只是告诉java文件，不属于该包的类能够到哪里去寻找而已：

package p1;
//import p2.Test2

public class Test1 {
public static void main(String[] args) {
p2.Test2 t;//Test2 t if we import p2.Test2 before;
}
}

访问修饰量

修饰类，变量，方法时：

public公共，任何地方都能使用；

private私有，只能在类中使用；

不加修饰词=default，包内其他类可以用；

protected继承，只能继承的子类可以使用；

访问修饰符：public protected default private
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
public：对所有类可见。使用对象：类、接口、变量、方法
protected：对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private：在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
外部如何访问内部的私有成员变量适用本类中的共有方访问本类中的私有成员变量。

public class PackageSample01 {//public代表其他任何类都能访问成员变量public String name;//private代表只能在当前类中使用private void sayHello(){System.out.println("Hello World");//输出Hello World}//不写修饰符代表是默认修饰符，只能被包中其他类访问void sayGoodbye(){System.out.println("Good bye!");//输出Good bye!}public static void main(String[] args) {//主方法 PackageSample01 packageSample01 = new PackageSample01();packageSample01.sayHello();}
}

运行结果如下：

封装

封装（Encapsulation）面向对象三大特性之一。封装的概念是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。封装的好处是只能通过规定的方法访问数据，隐藏类的实例细节，方便修改和实现。

封装的概念是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的好处是只能通过规定的方法访问数据，隐藏类的实例细节，方便修改和实现。当我们使用一个类时只关注这个类能解决什么问题，并不关注这个类是如何实现的。

封装：

1.封装即隐藏功能的实现细节；

2.良好的封装代码更容易阅读和维护；

3.利用对象与方法是实现封装的直接途径。

对成员变量进行续写封装
对成员变量进行读写封装，是为了不允许用户修改某一些成员变量

对只允许读，不允许写的变量，只生成get方法，不生成set方法

public class MobileNumber {private String owner;private String areaCode;private String mobileNumber;//getter方法，用于读取成员变量的内容//getter书写格式，public 成员变量类型 get 成员变量名(),PS:首字母大写public String getOwner() {//this关键字代表当前对象的...return this.owner;}public String getAreaCode() {//this关键字代表当前对象的...return this.areaCode;}//setter方法，setter方法用于设置成员变量的内容
//setter书写格式：public void set成员变量名(新的数据参数)public void setOwner(String owner) {this.owner = owner;}public void setAreaCode(String areaCode) {this.areaCode = areaCode;}
}public class MobileNumberTestor {public static void main(String[] args) {MobileNumber mobileNumber=new MobileNumber();mobileNumber.setOwner("shabi");String owner= mobileNumber.getOwner();System.out.println(owner);String areaCode=mobileNumber.getAreaCode();System.out.println(areaCode);}
}

运行结果如下：

面向对象特性之继承和多态

1.继承

类与类之间同样具有关系。例如，平行四边形是四边形，正方形、矩形也是平行四边形，平行四边形与四边形具有共同特性。如果把平行四边形看作四边形的延伸，那么平行四边形就复用了四边形的属性和行为，同时添加了平行四边形特有的属性和行为，如平行四边形的对边平行且相等。可以把平行四边形类看作是从四边形类中继承的，Java语言中，将类似于平行四边形的类称为子类，将类似于四边形的类称为父类或超类。值得注意的是，在阐述平行四边形和四边形的关系时，可以说平行四边形是特殊的四边形，但不能说四边形是平行四边形。所以，继承是实现重复利用的重要手段，子类通过继承复用了父类的属性和行为的同时，又添加了子类特有的属性和行为。

优点 1.功能复用：将已有的属性和行为继承过来，实现功能的复用，节省了大量工作。
2.便于扩展功能：在已有功能的基础上，更容易建立、扩展新功能。
3.结构清晰，简化认识：同属于一个继承体系的相关类，他们之间结构层次清晰，简化了人们对代码结构的认识。
4.易维护性：不同类之间的继承关系，让事物之间保持一致性，大大降低了维护成本。
缺点
打破了封装性：父类向子类暴露了实现细节，打破了父类对象的封装性。
高耦合性：类与类之间紧密结合在一起，相互依赖性高。

2.多态

将父类对象应用于子类的特征就是多态。比如创建一个螺丝类，螺丝类有两个属性：粗细和螺纹密度；然后再创建了两个类，一个是长螺丝类，一个是短螺丝类，并且它们都继承了螺丝类。这样长螺丝类和短螺丝类不仅具有相同的特征（粗细相同，且螺纹密度也相同），还具有不同的特征（一个长，一个短，长的可以用来固定大型支架，短的可以固定生活中的家具）。即，一个螺丝类衍生出不同的子类，子类继承父类特征的同时，也具备了自己的特征，并且能够实现不同的效果，这就是多态化的结构。

多态指的是在一个类中定义的属性和功能被其他类继承后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同行为特性。例如，当听到“Cut” 这个单词时，理发师的行为表现是剪发，演员的行为表现是停止表演等。不同的对象，所表现的行为是不一样的。
多态简单的说就是“一个函数，多种实现”，或是“一个接口，多种方法”。多态性表现在程序运行时根据传入的对象调用不同的函数。
实现多态，有二种方式，覆盖，重载
覆盖(override)，是指子类重新定义父类的虚函数的做法。
重载(overload)，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

3.ArrayList列表类的使用

ArrayList 类是一个可以动态修改的数组（比普通的数组速度慢），与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。

ArrayList 类位于 java.util 包中，使用前需要引入它：

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

java第六、七章复习相关推荐

第五六七章（PTA复习）
第五六七章图形界面线程 IO 图形界面主要的布局管理器类包括流布局(FlowLayout).边界布局(BorderLayout).网格布局(GridLayout).卡片布局 (CardLa ...
NLP复习资料(3)-六~七章：马尔科夫模型与条件随机场、词法分析与词性标注
NLP复习资料 1.第六章马尔科夫模型与条件随机场 2.第七章词法分析与词性标注国科大,宗老师<自然语言处理>课程复习笔记,个人整理,仅供参考. 1.第六章马尔科夫模型与条件随机场 ...
概率论||期末考试复习手写笔记-第五六七章（知识点+例题）第五章常用统计分布第六章参数估计第七章假设检验
第五章常用统计分布考点一:常用统计量考点二:三大统计分布考点三:抽样分布(单正态总体+双正态总体) 第六章参数估计考点一: 估计量的评价标准(无偏性+有效性+相合性) 考点二:点估计的常 ...
团队项目3.0与第六七章读后感
5.Scrum团队成立 5.1 团队名称:Aimee 团队目标:Follow the step of the sunshine ! 团队口号:We are best! ...
【封神台 - 掌控安全靶场】尤里的复仇 Ⅰ 小芳！一二三四五六七章
[封神台 - 掌控安全靶场]尤里的复仇小芳! 第一章:为了女神小芳! SQL注入攻击原理实战演练一.判断是否存在sql注入漏洞二.判断字段数三.判断回显点四.正式注入五.sql自动化注入 ...
Core Java 读后感 - 第七章异常、断言和日志
第七章异常.断言和日志 7.1 处理异常如果由于出现错误使得某些操作没有完成, 程序应该: 返回到一种安全状态,并能够让用户执行其他命令允许用户保存所有工作的结果,并以妥善的方式终止程序异常处 ...
Java六-七章总结
1-1 介绍类与对象类(class)和对象(object)是两种以计算机为载体的计算机语言的合称.对象是对客观事物的抽象,类是对对象的抽象.类是一种抽象的数据类型. 1.类与对象的定 ...
Java编程思想—第三四五六七章
1.对象引用若两个对象进行赋值操作,d1=d2,此时若操作d1或者d2,都会改变,即此时两个对象指向同一个堆对象.若想只改变值,可d1.v=d2.v. 2.短路即一旦确定一个式子的正误,式子后面部 ...
JAVA(第六版)——期末复习2
目录前言第2章基本数据类型与数据一. 单选题(共20题,50分) 二. 填空题(共5题,12.5分) 三. 判断题(共14题,37.5分) 总结前言博主复习食用,也希望可以帮到最近期末复习 ...

java第六、七章复习

面向对象认知概述

类与对象的定义

类与对象的关系

Java创建类的语法

面向对象程序设计的特点

封装

继承

多态

面向对象思想

介绍类与对象

对象

类

类与对象的关系

类和对象的区别

成员变量和类变量的区别：

成员方法

成员方法的参数

面向对象特性之封装

访问修饰量

封装

面向对象特性之继承和多态

1.继承

2.多态

3.ArrayList列表类的使用

java第六、七章复习相关推荐

最新文章

热门文章