java——面向对象详细介绍（一）_java

java——面向对象详细介绍（一）

1、什么叫面向对象？

面向对象(Object-Oriented，简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起，组合成一种新的复合数据类型，然后使用新创建的复合数据类型作为项目的基础。

面向对象是一个很抽象的概念，它相对面向过程而言。

过程与对象都是一种解决问题的思想。

面向过程：强调的是功能行为,一种过程,先干啥,再干啥;

面向对象：将功能封装到对象里，强调的是具备某功能的对象;

按照面向对象的思想，可以把任何的东西看做对象！

面向对象的三个特征：

封装(Encapsulation);

继承(Inheritance);

多态(Polymorphism)。

我的总结：

面向过程：强调的是具体的功能实现；（执行者）

面向对象：强调的是具备功能的对象。（管理者）

2、类

类(class)是Java 语言的最小编程单位，也是设计和实现Java 程序的基础，本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。

我的总结：类是抽象的，对象是具体的，实实在在的！

类的定义：

[修饰符] class 类名{

1~n个构造方法；

0~n个字段；

0~n个方法

}

定义类，其实就是定义类里面的对象

对象包含：

状态；（属性）

功能、行为；（方法）

通过类来描述对象；

状态--------成员变量；

功能、行为——方法；

Eg：

class Person{
//属性
   private String name;
   private int age;
   private int sal;
   //方法
   public void show(){
      System.out.println("个人情况："+name+age+sal);
   }
}

3、构造方法

构造方法：用来构造类的实例（每一个类都默认有一个无参的构造方法，得使用new调用）

字段：类或对象所包含的数据，对类状态的一种描述；

方法：类或对象的特征或行为

作用：

给类中的字段进行初始化，可以用来创建对象。

特点：

方法名与类名相同

不用定义返回值类型

不需要写return语句

注意：

默认构造方法的特点。

多个构造方法是以重载的形式存在的。

构造方法的重载:（需要哪个就去适配哪个，调用哪个）

this([实参]);调用当前类的构造方法

注意: this([实参]);必须放在构造器的第一行;

对象的产生格式：

类名称对象名 = new 类名称();

因为有(),所以是方法,实际上它就是构造方法，并且是非私有的构造方法。

如：

CellPhone cp = new CellPhone();

Eg：
 
class Person{
 
   private String name;
 
   private int age;
 
   private int sal;
 
   public void show(){
 
      System.out.println("个人情况："+name+age+sal);
 
   }
 
 
 
   public Person(String name) {
 
      super();
 
      this.name = name;
 
   }
 
 
 
   public Person(String name, int age) {
 
      super();
 
      this.name = name;
 
      this.age = age;
 
   }
 
 
 
   public Person(String name, int age, int sal) {
 
      super();
 
      this.name = name;
 
      this.age = age;
 
      this.sal = sal;
 
   }
 
}

4、static关键字

特点：

随着类的加载而加载

优先于对象存在

被所有对象所共享

可以直接被类名调用

使用注意：

静态方法只能访问静态成员

但是非静态成员方法可以访问静态成员;

静态方法中不可以使用this，super关键字

主方法（main）是静态的（可以利用类名去调用静态的main方法，很正常！但是会陷入死循环，导致内存溢出，jvm自动停止！）

public static void main(String[] agrs){}

可修饰字段,方法。

用static 修饰的成员表示它属于这个类共有，而不是属于该类的单个实例。

static 修饰的字段 == 类字段

static 修饰的方法 == 类方法

没使用static修饰的字段和方法，成员属于类的单个实例，不属于类。

没有static 修饰的字段 == 实例字段

没有static 修饰的方法 == 实例方法

类和实例访问字段和方法的语法：

访问类成员：类.字段类.方法

访问实例成员：实例.字段实例.方法

我的总结：

static 修饰的字段和方法，既可以通过类调用，也可以使用实例调用；

没static 修饰的字段和方法，只能使用实例来调用（建议使用:类名来调用; 其实在底层,对象调用类成员,也会转换类名调用）

static关键字不能与this，super同时连用！

5、匿名对象

一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量;

特点：

对方法或字段只进行一次调用时；

可作为实际参数进行传递；

只在堆里面开辟存储区域,

只能使用一次, 使用完就被销毁了;

何时使用？只拿来用一次！！

new Person();表示匿名对象,没有名字的对象

new Person().age = 17;//使用一次之后就被销毁了

6、this关键字

特点：this表示当前对象。

当前对象 ←→ 当前正在调用实例成员的对象

换言之：谁调用了方法，谁就是当前对象。

什么时候使用this关键字呢？

方法间的相互调用;

this.字段;

构造器中相互调用，但是此时this([参数])必须写在构造方法第一行。

this不能用在static修饰的方法里和static修饰的代码块里;

Eg：构造方法中的this.name = name;

7、面向对象之封装

封装的两个含义：

1.把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类)；

2."信息隐藏", 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;

封装机制在程序中的体现是：

把描述对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中，并保证外界不能任意更改其内部的字段值，也不允许任意调动其内部的功能方法。

程序中的一种体现：

通常将类中的成员变量私有化(private)，通过对外提供方法（setXxx,getXxx）,可对该变量(xxx)进行访问。

boolean 类型的变量没有getXX,只有 isXX;

 
Eg：
 
class Person1{
 
   private String name;
 
   private int age;
 
   private int sal;
 
  
 
   public String getName() {
 
      return name;
 
   }
 
 
 
   public void setName(String name) {
 
      this.name = name;
 
   }
 
 
 
   public int getAge() {
 
      return age;
 
   }
 
 
 
   public void setAge(int age) {
 
      this.age = age;
 
   }
 
}

8、访问修饰符

private 类访问权限:本类内部可以访问,不能继承到子类;

default 什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;

protected 子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;

public 公共访问权限:任何地方都可以访问,能继承到子类;

总结：

9、类的设计分析

分析思路：

根据要求写出类所包含的字段；

所有的字段都必须私有化；

封装之后的字段可通过setter和getter设值和取得；

按需求可添加若干构造方法；