Javase8面向对象（面向对象思想面向过程和面向对象什么是面向对象）

CsDn.FF

已于 2023-02-08 06:46:49 修改

阅读量172

点赞数 2

分类专栏： java基础知识文章标签： java 开发语言 intellij-idea

于 2022-05-21 09:55:55 首次发布

本文链接：https://blog.csdn.net/weixin_56800176/article/details/124851824

版权

java基础知识专栏收录该内容

21 篇文章 1 订阅

订阅专栏

作者有话说：

java作为面向对象语言，所以学习java一定要知道什么是面向对象，他和面向过程有什么区别？

面向过程和面向对象

面向过程：procedure oriented programming 缩写 POP

面向对象：object oriented programming 缩写 OOP

面向过程和面向对象

面向过程：procedure oriented programming 缩写 POP

1）分析问题

2）提出解决问题的步骤

3）实现步骤

面向对象：object oriented programming 缩写 OOP

1）以分类的方式进行思考和解决问题

2）先对整体关系作出分类

3）根据不同的类深入对细节的处理。

面向对象和面向过程不能相互取代，两者相辅相成，面向对象关注于从宏观上把握事物之间的关系，具体细节处理还得靠面向过程

java类

什么是类？

类是一个模板，它描述一类事物的属性和行为的集合.

类是表示一个客观世界某类群体的一些基本特征抽象

类的结构

成员变量：事物属性的描述；

   写在类中,类型可以是java中所支持的所有类型成员变量在类中定义时可以不给其赋值,在创建对象时,java会为其赋值创建对象时,会将类中的成员变量给每个对象复制一份.

         String name;
         int price;
         String color;

方法:事物的行为；（可以做的事情）

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段

构造方法：初始化对象；

public Phone(String name,int price){
              System.out.println("有2个参数的构造方法");
                this.name = name;
                this.price = price;//方法并且是构造方法
          }

内部类：即在类体中声明的类。

块：一段没有名称的代码块

类的定义

第一步：发现类

类的声明格式为: [访问权限修饰符] [修饰符] [类标识符] [类名]{ }

如：

public  [修饰符]  class Xxx {

修饰符：final,abstract或者不带修饰符

Java类名的命名规范: 类名首字母大写，尽量做到见名知意

第二步：发现类的共有属性(成员变量)

成员变量是定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量在创建对象的时候会从类中复制一份到对象中。

成员变量可以被类中方法、构造方法和特定类的语句块访问。

成员变量的作用范围为整个类体。

第三步：发现类的方法

方法声明格式为:

[访问权限修饰符] [修饰符]/ void start(){

System.out.println("执行代码");

[return 返回值;]

}

java对象

对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例

对象的创建和使用

1.创建和使用对象

Phone Hw = new Phone();

使用Hw变量访问对象中的成员变量和成员方法

--同一类的每个对象有不同的成员变量存储空间。

--同一类的每个对象共享该类的方法。

类是一类事物的抽象概念,是一个模型.

对象是由这个模型所创造的一个个具体存在的,实实在在存在的实例，所以创建对象的过程也叫实例化对象.

现实生活中先有对象后有类,而编程时先设计类后创建对象.

变量分类

成员变量

成员变量是定义在类中，方法体之外的变量。成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。成员变量在创建对象的时候会从类中复制一份到对象中。成员变量可以被方法、构造方法和特定的语句块访问。成员变量的作用范围为整个类体。

局部变量

在方法、构造方法或者语句块中定义的变量被称为局部变量。局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。局部变量在使用前必须初始化赋值。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

方法分类

成员方法

成员方法是定义在类中。

语法格式：

修饰符返回值类型方法名( 参数列表) {

方法体语句；

[return 返回值]

}

构造方法

构造方法名与类名相同,且没有返回值,且不需要使用void修饰。

• 作用:在构造方法中为创建的对象初始化赋值,

• 在创建一个对象的时候，至少要调用一个构造方法。

• 每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。

• 一个类可以有多个构造方法。

例： public class Car{

public Car(){ //这个构造方法无参}

public Car(String name){ // 这个构造方法有一个参数：name }

}

方法重载

● 方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。

● 参数不同（三方面）

1.数量不同

2.类型不同

3.顺序不同

调用时，会根据不同的参数表选择对应的方法。

• 注意：方法重载跟方法的返回值类型没有任何关系

对象和引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。

Java 中的对象是通过引用对其操作的。

创建一个对象：

class Student{
String class; 
String name; 
String grade; 
}
Student s= new Student();

1）右边的“new Student()”，是以Student类为模板,在堆空间里创建一个Student类对象。

2 ）左边的“Student s ”创建了一个Student类型引用变量。所谓Student类的引用，就是以后可以用来指向Student 对象的对象引用。

3）”=”操作符使对象引用指向刚创建的那个Student对象。

我们可以把这条语句拆成两部分：

Student s;

s= new Student();

这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。

new Student();这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，

我们看不见，也摸不着,对象没有名字，也就没法直接访问它,我们需要通过对象引用来间接访问对象。

car2 = car1 ；这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。

值传递与引用传递

Java 中进行方法调用中传递参数时，参数传递有两种：

值传递： ( 形参数类型是基本数据类型 ) ：方法调用时，实际参数把它的值传递给

对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是

两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

引用传递： ( 形参数类型是引用数据类型参数 ) ：也称为传地址。方法调用时，实

际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形

式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下

来，所以方法执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象

本身。

this关键字

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class Demo{
 private int a;
 public Demo(int a){
 this.a = a; 
    }
public int getA(){
 return a; 
    }
public void setA(int a){
 this.a = a; 
  }
}

static 被称为静态，可以用来修饰类的属性 , 方法 , 代码块 , 内部类。

• 随着类的加载而加载

• 优先于对象存在

• 修饰的成员，被所有对象所共享

• 可不创建对象，直接被类调用

静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。

static 方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用

在 static 方法内部只能访问类的 static 属性，不能访问类的非 static 属性 ,static 属性先加载。

public class TicketSeller{ 
private static int ticket=11;/ /票数只有一份 声明为静态的 
public static void sellticket(){ 
ticket=ticket-1; 
System.out.println("卖票的静态方法"); 
  }
}
public class Test{ 
public static void main(String[] args) {
 TicketSeller .sellticket();/ /没有创建对象也可以访问静态方法 
  }
}

代码块

代码块在类中声明，类似一个没有名称的方法体 ( 代码块 ) ，代码分实例块和静态块

实例块：每次创建对象时自动调用

{

// 任何符合语法的 Java 代码

}

静态块：类加载时自动调用，仅一次，与是否创建对象无关。

static {

// 任何符合语法的 Java 代码

}

包

包的概念：

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：

避免类重名

按照不同功能管理类

控制访问权限

包（package）的命名规范：

在包名中，可以使用.号来区分包的级别；包名一般情况下是小写

第一级指该项目的类型，如com,org,gov等，

第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei

等

第三级指项目的名称，如：bcms,oa,erp,cms等

第四级指项目模块的名称，如：bean,action,exception等

● 包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限

● 导入外部包的类，关键字“

import”

访问权限修饰符

Java语言有四个权限访问修饰符，权限从大到小依次为：

1）public ：公共权限修饰类、属性、方法。可以被任意类访问

2）protected：受保护的权限修饰属性、方法。

可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。

3）default：同包权限修饰类、属性、方法。只能被同包的类访问

4）private：私有权限修饰属性、方法。只能在本类中访问

面向对象特征

面向对象语言的三大特征：封装继承多态

封装：

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

封装的好处：

隐藏类的实现细节

只能通过规定方法访问

方便加入控制语句

方便修改实现

public class Demo{ 
private String name; 
public String getName (){ 
return name; 
   }
public void setName(String name){
 this.name = name;
  } 
}

继承：

继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径。

● 继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，

并能扩展新的能力。

● 在JAVA中使用extends关键字来表示继承关系。

● JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个

直接父类。

● 继承之后子类可以调用父类的所有非私有属性和非私有方法

继承是代码重用的一种方式：

继承的形式：

[访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}

public class Animal{ 
public void eat(){} 
}
public class Dog extends Animal{ 
public void play(){} 
}
子类对象可以直接调用父类的方法，强调复用性
 Dog dog = new Dog (); 
 dog.eat();

名词

· Dog 类是 Animal 类的子类 , Animal 类是 Dog 类的父类

·Dog 类是 Animal 类的派生类 , Animal 类是 Dog 类的基类

继承的传递性

C 类从 B 类继承 ,B 类又从 A 类继承

那么 C 类就具有 B 类和 A 类的所有非私有属性和非私有方法

当一个没有继承任何一个类时 ,jvm 会默认让类继承 Object 类

Object 是 java 为所有类提供的基类

继承中的构造方法

子类构造方法会先调用父类构造方法

使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无

参数的构造方法。

super关键字用途

• 使用super关键字访问父类成员

• 用super.成员变量名来引用父类成员变量

• 用super.方法名（参数列表）访问父类的方法。

• 用super.构造方法(参数列表)访问父类构造方法

误区: 不要把super误认为是父类对象.在创建子类对象时, 不会创建父类对象. 只会将父类中的信息加载到子类对象中存储.

方法的重写(OverRide)

● 应用场景

当父类的方法实现不能满足子类需求时 , 可以对方法进行重写 ( override)

● 在子类中可以根据需要对从基类中继承来的方法进行重写。

● 方法重写规则

• 方法名相同、参数列表相同；

• 返回值类型相同；

• 访问权限不能小于父类权限 ;

注意：构造方法 , 静态方法不能重写 , 成员变量不存在重写

抽象类

抽象方法

• 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现 .

• 抽象方法必须用 abstract 关键字进行修饰 .

● 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

● 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。

● 用 abstract 修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

● 特点 :

• 抽象类不能被实例化，但可以有构造方法 , 因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

● 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

多态：

同一种事物，在不同时刻表现不同的状态

● 多态存在的三个必要条件

● 要有继承（包括接口的实现） ( 前提条件 )

● 要有重写 ( 前提条件 )

● 父类引用指向子类对象

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{ 
…… 
}
class Cat extends Animal{ 
…… 
}
class Dog extends Animal {
 …… 
}
Animal x = new Cat() //Animal 的引用指向Cat的对象

多态环境下对成员方法的调用

class Animal{ void show() { 
System.out.println(“Anmial"); 
} 
}
class Cat extends Animal{ 
void show() 
{ 
System.out.println(“cat"); 
} 
}
 Animal x = new Cat() x.show() //调用的是子类中的方法 简单的说：编译看左边，运行看右边。

多态环境下对静态成员方法的调用

class Animal{ 
static void show() { 
System.out.println(“Animal"); 
  } 
}
class Cat extends Animal { 
static void show() { 
System.out.println(“Cat"); 
  } 
}

 Animal x = new Cat() x.show() //调用的是动物类中的静态成员方法。 简单的说：编译和运行都看左边。

多态环境下对成员变量的调用

class Animal{ 
int num = 3; 
}
class Cat extends Animal { 
int num = 4; 
}
Animal x = new Cat() x.num; //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

方法参数具有多态性

class Animal{ 
void eat() {} 
}
class Cat extends Animal{ 
void eat() {} 
}
class Dog extends Animal{ 
void eat(){} 
}//方法的形式参数类型是父类类型，而传递的实际参数可以是任意 子类的对象 
method(Animal animal){ 
animal .eat(); 
}

方法参数多态性的好处：提高代码的扩展性

向上转型

class Animal{ 
void eat(){ } 
}
class Cat extends Animal{ 
void look() { 
System.out.println("看家"); 
} 
} 
 Animal x=new Cat() //向上转型，Cat对象提升到Animal对象 
x.eat() //只能使用父类中的方法 
x.look() //报错！不能使用子类中的方法

向上转型的作用是：提高程序的扩展性。

向下转型

class Animal{ 
void eat(){ } 
}
class Cat extendsAnimal{ 
void look() { 
System.out.println("看家"); 
} 
} 
 Animal x=new Cat() Cat m=(Cat)x; //向下转型 
m.eat() ; 
m.look();//子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。

final关键字

● final 用于声明属性，方法和类。

• 属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。

• 方法:子类里不可以重写。

• 类:不能被定义为抽象类或是接口,不可被继承。

● final属性赋值

● 在声明时同时赋值，往往与static一起使用。//数据不能在方法体中被修改

● 声明时不赋值，必须在构造方法中逐一赋值。

● 总的原则：保证创建每一个对象的时候，final属性的值是确定的。

接口

认识一下接口

public interface MyInterface {

int num = 10;

public void foo() ；

public static void test(){

}

public default void test1(){

}

}

接口的定义：

使用 interface 关键字用来声明一个接口。

[ 访问修饰符 ] interface 接口名称 [extends 其他的接口名 1,…. 其他的接口名 n]

{

// 声明常量抽象方法静态方法默认方法

}

接口的使用：

类使用 implements 关键字实现接口。在类声明中， Implements 关键字放在class 声明后面。

[ 访问修饰符 ] class 类名 implements 接口名 1 ，接口名 2……{ }

结合继承：

[ 访问修饰符 ] class 类名 extends 父类名 implements 接口名 1 ，接口名 2……{ }

接口的特性：

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字

• 接口中方法可以是抽象的,静态的,默认的

• 接口中声明的属性默认为 public static final 的

• 接口不是被类继承了，而是要被类实现

• 接口不能实例化对象

• 与继承关系类似，接口与实现类之间存在多态性

• 一个接口能继承其它多个接口

• 当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须声明为抽象的类

CsDn.FF

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Javase8面向对象（面向对象思想面向过程和面向对象什么是面向对象）

目录面向过程和面向对象面向过程：procedure oriented programming 缩写 POP面向对象：object oriented programming 缩写 OOPjava类什么是类？类的结构面向过程和面向对象面向过程：procedure oriented programming 缩写 POP1）分析问题2）提出解决问题的步骤3）实现步骤面向对象：object oriented programming 缩写 OOP1）以分类的方式进
复制链接

扫一扫