面向对象

最新推荐文章于 2024-01-25 15:46:07 发布

Friendy89

最新推荐文章于 2024-01-25 15:46:07 发布

阅读量473

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/Friendy89/article/details/8957586

版权

Java基础专栏收录该内容

20 篇文章 0 订阅

订阅专栏

-------android培训、java培训、期待与您交流！ ----------

面向对象：

什么事对象：对象是类中事实存在的个体。

什么是面向对象：面向对象是将功能封装进对象，强调具备了功能的对象。它是一种思想。

举个例子，假如我们去饭店吃饭，到饭店要找服务员点菜，那么服务员就是一个对象，而至于服务员拿着菜单后怎么把我们的菜端上来，我们不用管，这就叫面向对象。服务员拿着菜单后的一系列行为比如去厨房送菜单以及端菜的动作等等就是一个面向过程。

面向对象的三个特征：封装，继承，多态

类与对象之间的关系：类是对生活中某一类事物的描述（一种抽象概念），对象是该类事物实实在在存在的个体。

类的定义：定义类其实在定义类中的成员(成员变量和成员函数)。

成员变量特点：
     成员变量定义在类中，在整个类中都可以被访问。
     成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
     成员变量有默认初始化值。
局部变量特点：
     局部变量只定义在局部范围内，如：函数内，语句内等。
     局部变量存在于栈内存中。
    作用的范围结束，变量空间会自动释放。
    局部变量没有默认初始化值。

创建对象的格式：

类名对象名称 = new 类名(); 例如：class Person = new Person();

创建对象其实就是在堆内存里开辟存储空间；

创建对象和使用对象范例：

class  CellPhone{
    String brand = "google";
    String color = "red";
    double price;
	
    public void show()
    {		
    	System.out.println(brand+ "手机是"+color+"色的"+"价值"+price);
    }
}
class CellPhoneDemo{
	public static void main(String[] args) {
		CellPhone cp = new CellPhone();//建立对象
		cp.color = "black";//对对象的属性进行修改
		cp.show();//使用对象的功能。
	}
}

匿名对象特点:
   1，对方法或字段只进行一次调用时；
        new Car().show();
        new Car().run();
   2，可作为实际参数进行传递；
        public void show(Car c){ }
        new Car().show(new Car());
    3，只在堆内存中开辟空间，而没有在栈内存的引用。

一，封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

例如，电脑主机，它将主板、cpu、内存、显卡等封装在机箱中，它们只需要对外提供一些接口和卡槽之类的电脑就可以调用机箱内部功能。

好处：

将变化隔离。

便于使用。

提高重用性。

提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。

把属性都隐藏，提供公共方法对其访问。

构造函数：用来完成对象的初始化的方法,要完成类的实例化，产生一个对象

特点：1，函数名与类名相同

2，不用定义返回值类型

3，没有具体的返回值。

作用：给对象进行初始化。

注意：

构造方法不能继承，更不可以被重写。
构造方法可以被重载。

this关键字：

特点：this代表本类对象的引用。

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

当在函数内需要用到调用该函数的对象时，就用this。

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

范例：

class Student
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
}

static关键字：用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

1，随着类的加载而加载

2，优先于对象存在

3，被类中所有对象所共享

4，可以直接被类名调用

使用注意：

1，静态方法只能调用静态成员，不能调用非静态成员。
非静态方法可以调用静态成员，也可以调用非静态成员。
2，在静态方法中不允许出现this，super关键字。
this代表对象，而静态方法执行时还没有对象呢！
3，主函数是静态的。
静态是有访问局限性的，只能访问静态的内容。

静态成员变量和非静态成员变量的区别？
1，非静态成员变量又称为实例变量。
静态成员变量又称为类变量。
2，非静态成员变量，随着对象的创建而存在，随着对象的消失而消失。
静态成员变量，随着类的加载而存在，随着类的消失而消失。
3，非静态变量存在于对象堆内存中。
静态变量存在于方法区中。
4，非静态变量只能被对象所调用。
静态变量可以被类名调用，也可以被对象调用。

private关键字：是一个权限修饰符。用于修饰成员(成员变量和成员函数)

被私有化的成员只在本类中有效。

常用之一：

将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性。

二，继承

概念：

当多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可。多个类就是子类，单独这个类称为父类或者超类。子类可以直接访问父类中的非私有的属性和行为。子类和父类是通过 extends 关键字让类与类之间产生继承关系。比如学生和工人都有吃饭和睡觉的行为，我们可以将这两个行为单独提取出来封装在一个类中，然后学生和工人只需要继承这个类就可以了。

继承的好处：

继承的出现提高了代码的复用性。他不需要在子类对象中再写父类中已有的功能

继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：子类不能直接访问父类的私有成员，但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。

继承的特点：

1，只支持单继承，不支持多继承

如，class A extends B,C...这样写是错误的

2，支持多层继承

       如，class A{}
           class B extends A{}
           class C extends B{}

函数的覆盖：

1，类与类之间的继承存在覆盖的关系，并且子类覆盖父类，必须保证子类的权限大于等于父类权限才可以覆盖，否则编译失败。

2，父类中的私有方法不可以被覆盖。

3，在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

方法覆写时应注意的规则：

1，方法名必须相同。

2，子类方法的返回值类型比父类方法的返回值类型更小或相等。
3，子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等。

4，子类方法的访问权限应比父类方法更大或相等。

5,覆盖方法有静态修饰时，静态只能覆盖静态，或者被静态覆盖。

代码演示：

class Person { 
	Person() { 
		System.out.println(("Person")); 
	} 
	Person(String name) { 
		System.out.println("name:" + name); 
	} 
} 
public class Chinese extends Person { 
	Chinese() { 
		super(); // 调用父类构造函数
		System.out.println("chinese"); 
	} 
	Chinese(String name) { 
		super(name);// 调用父类具有相同形参的构造函数
		System.out.println("name_2:" + name); 
	} 
	public static void main(String[] args) { 
		Chinese ch = new Chinese(); 
		ch = new Chinese("lisi"); 
	} 
}

子父类中构造函数特点：

在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super();

super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();

如果父类中没有空参数的构造函数，子类的构造函数中必须手动用super来指定要访问的父类中的构造函数。或者用this来指定访问本类中的构造函数。

为什么子类的构造函数都要去默认访问父类的构造函数呢？

因为子类继承了父类，可以访问父类中的已有的一些属性。在子类进行实例化的时候必须要为父类中的属性分配空间。并要进行初始化，所以必须要访问一次父类的构造函数，看看父类是如何对其属性进行初始化的。所以子类要实例化对象时，必须要先看父类的初始化过程。
结论：父类的构造函数，既可以给本类对象初始化，也可以给子类对象初始化。

this和super的区别：

1, this调用本类中的字段或方法。 super从子类调用父类中的字段或方法。

2， this可以调用本类构造方法，且有一个构造方法要作为出口。 super从子类调用父类的构造方法，不管子类如何安排最终一定会去调用，默认调用的是父类中的无参构造方法。

3， this调用自身构造方法时放在构造方法首行。 super调用父类构造方法时放在子类构造方法首行。

4，this表示本类对象。super表示父类对象。

注意：使用super()和this()在同一个构造方法中是不可能同时出现的。

对象的初始化顺序：静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过

抽象类：

定义：当多个类中出现相同功能，但功能主体不同，这是可以进行向上抽取，这时只抽取功能定义，而不抽取功能主体。也就是说如果一个方法中存在不可预知的方法实现，那么这个方法所在的类就应该声明为抽象类。

抽象类特点：

1，抽象方法只有方法声明，没有方法体，定义在抽象类中。

格式：修饰符 abstract 返回值类型函数名(参数列表) ；

2,抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象，因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖部分抽象方法，那么该子类还是一个抽象类。

5，特殊之处：抽象类中可以不定义抽象方法，这样做仅仅是不让该类创建对象。

例如我们简单定义一个学生的抽象类，学生都有学习的方法，但是每个学生学什么是不确定的所以要定义一个抽象类，代码如下：

abstract class Student
{
       abstract void study(); 
}

要调用这个抽象类必须通过子类来继承它，并且覆写掉他的方法，例如

class ProStudent extends Students
{
     public void study()
     {
        System.out.println("Pro Study");
     }
}

接口：当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

格式：interface 接口名{}

接口中的成员修饰符是固定的:

成员常量：public static final

成员函数：public abstract

记住：接口的成员都是public的。

接口的特点：

接口是对外暴露的规则。例如电脑的USB就是一个接口

接口是程序的功能扩展。

接口的出现降低耦合性。

接口可以用来多实现。

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

接口范例：

interface Inter
{ 
    public static final int NUM=3;
     public abstract void show(); 
} 
interface InterA 
{
      public abstract void method(); 
 } 
class Text implements Inter,InterA 
{ 
      public void show(){}
 } 
 class InterFaceDemo 
{ 
      public static void main(String[] args)
      { 
          Text t=new Text; 
          System.out.println(t.NUM);
          System.out.println(t.NUM); 
          System.out.println(t.NUM); 
      } 
}

interface接口和abstract抽象类的区别：

　　1，接口被继承时用的关键字是implements，而且可以同时implements多个interface，而抽象类被继承时用的关键字是extends，而且只能同时extends一个抽象类。

　　2，接口内定义的方法都是public的，而抽象类内的则不一定。

　　3，接口内定义的成员对象都是static或 final的，而抽象类不是(一定不能是final)

　　4，接口的方法不能有默认实现，只有一个申明，而抽象类内申明抽象的方法不能有实现，非申明abstract的方法可以有默认实现。

　　5，接口被implements时，所有方法都必须被实现，必须申明是public的，而抽象类被extends时只有抽象的方法才必须被实现，别的有默认实现的直接被继承过来。

面向对象之多态：

多态：可以理解为事物存在的多种体现形态。比如动物有猫，狗，狼，虎等多种形态

多态自始至终都是子类对象在做着变化。

1,多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高了程序的扩展性。

4，多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员

5，多态的应用

多态中，如果要调用子类中的特有方法时，就要将父类的引用强制转成子类类型,再通过子类调用特有方法。如，

Animal a = new Cat();//类型提升，向上转型

a.eat();

Cat c = (Cat)a;//强制将父类引用转成子类类型。

c.catchMouse();

6，多态的出现代码中的特点

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有则编译失败。如， Fu f = new zi();

f.method_1();

f.method_2();

f.method_3();

当父类中只有method_1和method_2方法时，上面语句编译失败

在运行时期：参阅对象所属的类中是否有调用方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）。

在多态中，静态成员函数的特点：

无论编译和运行都参考左边。

内部类：

定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类

访问特点：

内部类可以直接访问外部类中的成员，包括私有成员。

而外部类要访问内部类中的成员必须要建立内部类的对象

访问格式：

1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类对象。

格式

外部类名.内部类名变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

2,当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

static:内部类就具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？

outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

总结：

内部类定义在成员位置上：

可以被private static成员修饰符修饰。

被static修饰的内部类只能访问外部类中的静态成员。

内部类定义在局部位置上：

也可以直接访问外部类中的成员。

同时可以访问所在局部中的局部变量，但必须是被final修饰的。

范例：

class Outer
{
	int x=3;
	void method()
	{
		final int y=4;
		class Inner
		{
			void function()
			{
				System.out.println(y);
			}
		}
		new Inner().function(); 
	}
}


class InnerClassDemo1
{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}

匿名内部类：

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

代码演示：

abstract class Demo{
	abstract void show();
}
class Outer{
	private int num = 5;
	
	public void method(){
		//匿名内部类: 就是Demo的一个匿名子类对象；
		Demo d = new Demo(){
			void show()
			{
				System.out.println("show run..;........."+num);
			}
		};
		d.show();
	}
}

------- android培训、java培训、期待与您交流！ ----------

Friendy89

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象

面向对象的三个特征：封装，继承，多态类与对象之间的关系：类是对生活中某一类事物的描述（一种抽象概念），对象是该类事物实实在在存在的个体。类的定义：定义类其实在定义类中的成员(成员变量和成员函数)。成员变量特点：成员变量定义在类中，在整个类中都可以被访问。成员变量随着对象的建立而建立，存在于对象所在的堆内存中。成员变量有默认初始化值。局部变量特点：局部变
复制链接

扫一扫