黑马程序员_面向对象

最新推荐文章于 2024-09-05 11:00:53 发布

Crazy-J

最新推荐文章于 2024-09-05 11:00:53 发布

阅读量451

点赞数

文章标签： java

本文链接：https://blog.csdn.net/u010221057/article/details/22353551

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

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

一．对面向对象的理解

面向对象是相对面向过程而言的。

面向对象和面向过程都是一种思想。

面向过程强调的是功能和行为。

面向对象是将功能封装进对象，强调了具备功能的对象。

举例：将大象装进冰箱里

面向过程：打开冰箱存储进冰箱关闭冰箱

面向对象：冰箱.打开冰箱.存储冰箱.关闭

二．面向对象的特点：

1.是一种符合人们思考习惯的思想

2.可以将复杂的事情简单化

3.将程序员从执行者转换成了指挥者

4.完成需求时：先要去找具有所需的功能的对象来用。如果该对象不存在，那么创建一个具有所需功能的对象，这样简化开发并

提高复用。

三．类和对象的关系

1.类：对现实生活中事物的描述，对具体事物的抽象。

2.对象：就是这类事物，实实在在存在的个体。

3.想要描述：提取对象中共性内容，对具体的抽象。

现实生活中的对象举例：张三，李四

4.描述时：这些对象的共性有：姓名，年龄，性别，学习java的功能，映射到java中，描述就是class定义的类，具体对象就是对应

java在堆内存中用new建立的实体。

5.定义类，就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员。

属性对应类中的成员变量，行为对应类中的成员方法。

代码：

class Car//对car这类事物进行描述 {
	// 描述颜色
	String color = "红色";
	// 描述轮胎数
	int num = 4;
	// 运行行为
	void run() {

		System.out.println(color + ".." + num);
	}

}

6．对象的声明

格式：类名对象名=new 类名()；

说明：java语言中声明一个对象，并不给对象分配内存空间，只有在实例化一个对象时，才给对象分配内存空间。

举例：Car c = new Car();//c就是一个类类型变量。类类型变量指向对象。

四．成员变量和局部变量

1.成员变量定在在类中，有默认的初始化值。

2.局部变量定义在函数或者语句中，没有默认的初始化值。

3.作用范围：

成员变量作用于整个类中。

局部变量作用于函数中，或者由于语句中。

4.在内存中的位置：

成员变量：在堆内存中，因为对象的存在，才在内存中存在。

局部变量：在栈内存中。

五．匿名对象

1.匿名对象是对象的简化形式。

Car c=new Car();

c.num=4;

以上代码可以简化为：new Car().num=4;

2.匿名对象的两种使用方式：

当对对象方法仅进行一次调用的时

匿名对象可以作为实际参数进行传递

如果一个对象进行多次成员的调用时，必须给对象起一个名字。

3.匿名对象调用方法有意义，调用属性无意义。

代码new Car().num=4； new Car().run();会在堆内存中建立匿名对象。用完后会在某个时间段由java的垃圾回收来回收。

代码：

class CarDemo {
	public static void main(String[] args) {
		// 生产汽车。在java中通过new操作符来完成。
		// 其实就是在堆内存产生一个实体。
		// Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。

		// 需求：将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是：对象.对象成员
		// c.color = "blue";
		// Car c1 = new Car();
		// c1.run();//red 4;
		// Car c = new Car();
		// c.num = 5;
		Car q = new Car();
		show(q);
       // show(new Car());  
	}
	// 需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。
	public static void show(Car c) {
		c.num = 3;
		c.color = "black";
		c.run();
	}
}

六．Java的三大特征

1.封装（Encapsulation）

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

 好处：将变化隔离。

便于使用。

提高重用性。

提高安全性。

封装原则：将不需要对外提供的内容都隐藏起来。

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

关键字private

私有化，权限修饰符，用于修饰类中的成员（成员变量，成员函数）。

私有只在本类中有效。

私有仅仅是封装的一种体现形式。

常用于：

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

之所以对外提供访问方式，就因为可以在访问方式中就爱如逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性。

注意：private修饰符不能修饰类。

代码：

class Person
{
   //age被私有化，只能在本类中被调用
	private int age;
	public void setAge(int a)
	{
		if(a>0 && a<130)
		{
			age = a;
			speak();
		}
		else
			System.out.println("feifa age");
	}

	public int getAge()
	{
		return age;
	}
	private void speak()
	{
		System.out.println("age="+age);
	}
}

class PersonDemo
{
	public static void  main(String[] args)
	{		
Person p = new Person();

		//p.age = -20;
		p.setAge(-40);
		//p.speak();
	}
}

构造函数

特点：

函数名与类名相同

不用定义返回值类型

不可以写return语句

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

注意：

默认构造函数的特点。

多个构造函数是以重载的形式存在的。

当一个类中没有定义构造函数时，那么系统就会默认给该类加入一个空参数的构造函数。

当在类中定义了构造函数，默认的构造函数就没有了。

构造函数属于成员函数，也可以被私有化，但是私有化以后就不能创建对象了，因为对象不能进行初始化动作。

构造函数之间只能用this语句调用

构造函数和一般函数的区别：

构造函数和一般函数在写法上不同，在运行上也有不同。

构造函数在对象一建立就运行，给对象初始化。

而一般方法就是对象调用才执行，是给对象添加对象具备的功能。

一个对象建立，构造函数值运行一次。

一般方法可以被该对象调用多次。

什么时候定义构造函数？

当分析事物时，该事物存在一些特性或行为，那么将这些内容定义在构造函数中。

构造代码块

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

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，

而构造函数是给对应的对象初始化。

构造代码快中定义的是不同对象共性的初始化内容。

代码：

class Person
{
	private String name;
	private int age;
  //构造代码块
	{
		//System.out.println("person code run");
		cry();
	}

	Person()
	{
		System.out.println("A: name="+name+",,age="+age);
	}
	Person(String n)
	{
		name = n;
		System.out.println("B: name="+name+",,age="+age);
		//cry();		
	}
	/*
	public void setName(String n)
	{
		name  = n;
	}
	public String getName()
	{
		return name;
	}
	*/
	Person(String n,int a)
	{
		name = n;
		age = a;
		System.out.println("C: name="+name+",,age="+age);
		//cry();
	}

	public void cry()
	{
		System.out.println("cry......");
	}
}

public class  PersonDemo2
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();
		Person p2 = new Person("lisi");
	
		//System.out.println(p2.getName());
		//Person p3 = new Person("wnagu",10);
	}
}

关键字this

特点：this代表其所在函数所属对象的引用。

也就是说this代表它所在函数所属对象的引用。

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

但凡本类功能内部使用了了本类对象，都用this表示。

代码：

class Person
{
	private String name;
	private int age;
	Person (int age)
	{
		this.age = age;
	}
	Person (String name)
	{
		this.name = name;
	}
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public void speak()
	{		System.out.println("name="+this.name+"...age="+this.age);  
		this.show();   //this要省略  
	}
	public void show()
	{
		System.out.println(this.name);
	}
	
/*	需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。	*/
	public boolean compare(Person1 p)
	{
		return this.age==p.age;
	}
}

class PersonDemo3 
{
	public static void main(String[] args) 
	{
		Person1 p1 = new Person1(20);
		Person1 p2 = new Person1(25);
   //  调用compare()方法
		boolean b = p1.compare(p2);
		System.out.println(b);
//		Person p = new Person("lisi");
//		Person p1 = new Person("zhangsan");
//		p.speak();
//		p1.speak();
//		p.speak();
	}
}

this语句：

用于构造函数之间进行相互调用

this语句只能定义在构造函数的第一行，因为在初始化时要先执行。

代码：

public class PersonDemo4 {
   public static void main(String[] args) {
	  // new  Person();
	   Person p=new Person("haha",30);
	   p.speak();
	   Person p1=new Person("haha2",30);
	   p1.speak();
}
}  
 class Person 
 {
	 private String name;
	 private int age;
	 //构造代码块   
	 {
		 System.out.println("构造代码块");
	 }
	 Person()
	 {
//		this("haha");   //不允许这样调用   否则会造成死循环
		 System.out.println("person run");
	 }
	Person(String name)
	{   
		this();  //调用空参数的构造函数Person()
		this.name=name;
	}
	Person(String name,int age)
	{   
		this(name);  //p(name);
		//this.name=name;
		this.age=age;
	} 
	public void speak()
	{
	System.out.println("name="+this.name+"...age="+this.age);   //this就代表对象
		//this.show();      //此处的this应该是省略的  等同与 show();
		show();
	}
	public void show()
	{
		System.out.println(this.name);
	}
 }

关键字 static

是一个修饰符，用于修饰成员(成员变量，成员函数).

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，

还可以直接被类名调用。类名.静态成员。

static特点：

随着类的加载而加载。

也就说：静态会随着类的消失而消失。说明它的生命周期最长。

优先于的对象存在

明确一点：静态是先存在。对象是后存在的。

被所有对象所共享

可以直接被类名所调用。

实例变量和类变量

举例：

String name;//成员变量实例变量

Static String activity=”CN”;//静态的成员变量类变量

实例变量和类变量的区别：

存放位置

类变量随着类的加载而存在于方法区中。

实例变量随着对象的建立而存在于堆内存中。

生命周期

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失。

静态使用注意事项：

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

非静态方法既可以访问静态也可以访问非静态。

静态方法中不可以定义this，super关键字。

因为静态优先于对象存在。所以静态方法中不可以出现this。

主函数是静态的。

静态有利有弊

利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。

可以直接被类名调用。

弊端：生命周期过长。

访问出现局限性。(只能访问静态)

什么时候使用静态？

何时定义类变量？

当对象中出现共享数据时，该数据被static修饰。

对象中的特有数据要定义成非静态存在与堆内存中。

何时定义静态函数呢？

当功能内部没有访问到非静态数据（对象特有数据），这时候经爱过你该功能定义成静态的。

代码：

class Person{
	String name;// 成员变量，实例变量。
	static String country = "CN";// 静态的成员变量，类变量。

	public static void show() {
		System.out.println(country+"::::");		 this.haha();    //haha()是非静态方法
	}
	public void haha() {
	}
}
class StaticDemo {
	public static void main(String[] args) {
		Person p = new Person(); 
		// p.name = "zhangsan";
		// p.show();
		// System.out.println(p.country);
		// System.out.println(Person.country);
		Person.show();
	}
}

静态代码块

格式：

static {

静态代码块中的执行语句 }

特点：

随着类的加载而执行，只执行一次，并优先于主函数，用于给类进行初始化。

对象的初始化过程

构造代码块优先级高于构造函数，构造函数有针对性。

默认初始化à显示初始化à构造函数初始化

Person p = new Person("zhangsan",20);

该句话都做了什么事情？

因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。

执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

在堆内存中开辟空间，分配内存地址。

在堆内存中建立对象的特有属性。并进行默认初始化。

对属性进行显示初始化。

对对象进行构造代码块初始化。

对对象进行对应的构造函数初始化。

将内存地址付给栈内存中的p变量。

2.继承（extend）

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。

 多个类可以称为子类，单独这个类称为父类或者超类。

 子类可以直接访问父类中的非私有的属性和行为。

 通过extends关键字让类与类之间产生继承关系。class SubDemo extends Demo{}

所属关系：is a关系

好处：

继承的出现提高了代码的复用性。

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

继承的特点：

Java中支持单继承，不支持多继承，但是java保留了这种了这种机制。

Java支持多层继承，也就是一个继承体系。

class A{}

class B extends A{}

class C extends B{}

如何使用继承体系中的功能？

先查阅体系中父类的描述，因为父类中定义的是该体系中的共性功能，通过了解共性功能，就可以知道该体系中的基本功能。

在具体调用时，要创建最子类对象，原因如下：

因为有可能父类不能创建对象。

创建子类对象可以使用更多的功能，包括基本的也包括特有的。

图解：

除继承外的另一种关系：聚合(has a) “xxx中有xxx”

举例：球队中有球员

子父类出现后，类中成员的特点：

1.变量：如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量用this，子类访问父类中的变量用super，子类不能直接访问父类中私有内容。

super和this的用法相同

this代表本类应用

super代表父类引用

2.父类中函数的特点—覆盖（重写）override

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

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

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

覆盖注意事项：

覆盖时，子类方法权限一定要大于等于父类方法权限

静态只能覆盖静态。

覆盖的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

代码：

class Fu
{
   void show()   // public  该方法被定义为 public 时，若子类中show()为普通权限，无法复写  权限过小
    {
    	System.out.println("fu show");
    }
   void speak()   //private  普通的权限介于私有和public之间  所以在该方法为private时，子类中的方法为普通，还可以复写
    {
    	System.out.println("fu  speak");
    }
}
class Zi extends Fu1{
	
	 void show()
	    {   
		    super.show();   //子类中继续使用被覆盖的方法   用super.函数名
	    	System.out.println("zi show");
	    }
	    void speak()
	    {
	    	System.out.println("zi  speak");
	    }
} 
class ExtendsDemo3 {
    public static void main(String[] args) {
		Zi z=new Zi();
		z.show();   //调用子类的show方法
		
	}   
}

3.父类中构造函数的特点—子类实例化过程

在对子类对象进行初始化时，父类的构造函数都会运行，那是因为子类的构造函数默认第一行有一条隐式语句 super（），子类中所有的构造函数默认都会访

问父类中空参数的构造函数。

super（）会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）。

为何子类一定要访问父类中的构造函数？

因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据初始化的。

如果要访问父类中指定的构造函数，可以通过手动定义super（）语句的方式指定。

注意：super语句必须是定义在子类构造函数的第一行。

子类的构造函数第一行也可以是手动指定this语句来访问本类中的构造函数，子类函数中至少会有一个构造函数访问父类中的构造函数。

构造函数不存在覆盖。

当父类中没有空参数的构造函数时，子类必须手动通过super语句指定要访问父类中的构造函数。

父类中的构造函数也有super（）。

关键字 final

最终，修饰符，可以修饰变量，函数，类。

被final修饰的类不可以被继承。

被final修饰的方法不可以被复写。

final修饰的变量是一个常量。只能被赋值一次。

内部类只能访问被final修饰的局部变量。

public static final double PI=3.14;//全局常量

抽象类

抽象定义：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

举例：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象方法的由来：

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主

体的方法称为抽象方法。

举例：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

抽象类的特点：

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

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

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

抽象类中的方法要被使用，必须由子类复写其所有的抽象方法，如果子类只覆盖了部分抽象方法，那么该子类还是抽象类。

抽象类不可以被实例化，也就是不能用new创建对象。原因：

抽象类是由具体事物抽象出来的，本身是不具体的，没有对应的实例。

注意：

抽象类中可以不定义抽象方法，这样仅仅是为了不让该类建立对象。

抽象关键字可以和那些关键字不能共存？

final：不可以。被final修饰的类不能有子类，而被abstract修饰的类一定是父类。

private：不可以。私有后无法被覆盖。

static：不可以。static不能修饰抽象方法。

抽象类中是否有构造函数？

有。抽象类是一个父类，要给子类提供实例的初始化。

代码：

abstract class Student {
	abstract void study();

	// abstract void study1(); //此时的子类若不复写该方法，那么子类也是抽象类
	// 不是抽象方法
	void sleep() {
		System.out.println("躺着睡觉");
	}
}

class BaseStudent extends Student {
	//子类复写了父类中的抽象方法   才可以建立对象调用
	void study()
	{
		System.out.println("base study");
	}
	// abstract void study1();
}

class ChongCiStudent extends Student {
	void study() {
		System.out.println("chongci study");
	}
}
class Advstudent extends Student {
	void study() {
		System.out.println("adv study");
	}
}
class AbstractDemo {
	public static void main(String[] args) {
		// new Student();
		new BaseStudent().study();
		// new ChongCiStudent().sleep();
	}
}

接口（interface）

抽象类的另一种表现形式。

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

格式：

Interface { }

接口中的成员都是有固定的修饰符：

     全局常量   public static final
     抽象方法   public abstract
   接口的特点：

接口是对外暴露的规则。

实现规则，降低了事物之间的耦合性，所谓耦合性，就是紧密联系的程度。

 接口是程序的功能扩展。

 接口可以用来多实现。

代码：

interface Inter {
	public static final int NUM = 3;
	public abstract void show(); // 抽象的方法
}
interface InterA
{
   public abstract void show();	
}
interface InterB
{
   public abstract void show();	
}
class Demo1
{
  public void function(){}	
}
class Test2 extends Demo1 implements InterA,InterB
{
   public void show(){}	   
} 

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

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

接口与接口之间的多继承：

interface A
{
   public abstract  void  methodA();	
//   int show();
}
interface B  //extends A
{
   public abstract  void  methodB();
//   boolean show();
}
interface C  extends B,A     //接口之间的多继承关系
{
   public abstract  void  methodC();	
}

注意：

接口不可以创建对象，因为有抽象方法，只能由实现了接口的子类覆盖了接口中所有的抽象方法后，该子类才可以实例化，否则这个子类就是一个抽象类。

基本功能定义在类中，扩展功能定义在接口中。

接口和抽象类的异同点：

相同点：都是不断向上抽取而来的。

不同点：

抽象类需要被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

抽象类中可以定义抽象方法和非抽象方法，子类继承后可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。

抽象类的继承，是is a（所属关系）关系，在定义该体系的基本共性内容。

接口的实现是like a关系，在定义体系的额外功能。类在确定体系，接口在扩展功能。

3.多态

定义：某一类事物的多种存在形态。

举例：

人：男人，女人

动物：猫，狗

猫这个对象对应的类型是猫类型

猫x = new 猫();

同时猫也是动物中的一种，也可以把猫称为动物。

动物y = new 猫();

动物是猫和狗具体事物中抽取出来的父类型。

父类型引用指向了子类对象。

函数的重载和覆盖的特性就是多态性的体现。

多态的体现：

父类或者接口的引用指向或者接收自己的子类对象。

多态的前提：

必须是类与类存在继承或者实现关系。

要有覆盖操作。

多态的好处：

多态的存在提高了程序的扩展性和后期可维护性。

多态的弊端：

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

代码：

abstract class Animal {
	abstract void eat(); // 吃什么不确定
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃老鼠");
	}

	public void CatchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("啃骨头");
	}

	public void kanJia() {
		System.out.println("看家");
	}
}

class Pig extends Animal {
	public void eat() {
		System.out.println("饲料");
	}

	public void gongDi() {
		System.out.println("拱地");
	}
}
class DuoTaiDemo {
	public static void main(String[] args) {
		// Cat c=new Cat();
		// c.eat();
		// Dog d=new Dog();
		// d.eat();
		// Cat c1=new Cat();
		// function(c1);
		/*function(new Cat());
		function(new Dog());
		function(new Pig());*/
		/*
Animal c = new Cat(); //多态性的体现 c.eat();
		 */
		function(new Cat());
		function(new Dog());
		function(new Pig());
	}
	// 提取共性
	public static void function(Animal a) // 当有function(new Cat())时，此句代码就相当于Animal a=new Cat();
	{
		a.eat();
		// a.catchMouse(); //不可以定义
	}
}

多态中成员的特点

成员函数（非静态的）：

在编译时期：参阅引用类型变量所属类中是否有调用的方法，如果有，编译通过，

如果没有，编译失败。

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

总结：编译看左边，运行看右不边。

静态成员函数：

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

成员变量：

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

转型

向上转型

Animal a=new Cat(); 自动类型提升，猫直接提升成了动物类型，不能直接访问猫的特有方法。

作用：限制对特有方法的访问，提高程序扩展性。

如何调用猫的特有方法呢?--------向下转型(强制将父类引用转成子类类型)

Cat c=（Cat）a;

c.cathchMouse();

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

注意：

不能将父类对象转成子类对象

Animal a=new Animal();

Cat c=(Cat)a; ClassCastException 类型转换异常

我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。

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

内部类

定义：将一个类定义在一个类的里面，对里面的那个类就称为内部类（内置类，嵌套类）。

访问规则：内部类可以直接访问外部类中的成员，包括私有的，是因为内部类中持有了一个外部类的的引用

格式：外部类名.this

外部类访问内部类，必须建立内部类对象。

访问格式：

当内部类定义在外部类的成员位置上时

非私有时，可以在外部其他类中，直接建立内部类对象。

格式：

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

（new 外部类名）.（new 内部类名）

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

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

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

new Outer.Inner().function();

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

Outer.Inner().function();

注意：

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

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

 当内部类定义在局部位置上

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

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

代码：

/*
  内部类定义在局部位置上时，*/
class Outer
{
   int x=3;
   void method(final int a)  //此处的a为局部变量   不再对象中
   {    final int y=4;
	   class Inner
	   {
		   void function()
		   {
	        	System.out.println(a);
		   }
	   }
	  new Inner().function();
	   }
}

class InnerClassDemo3 {
	public static void main(String[] args) {
	  Outer out=new Outer();
	 //当对象调用method（）方法时，该方法被加载进栈内存中  a被赋值为5.该语句执行结束后，被释放
	  out.method(5);
	//当对象再次调用method（）方法时，该方法被加载进栈内存中  a被赋值为6.该语句执行结束后，被释放
	  out.method(6);	
	}
}

匿名内部类

就是内部类的简化写法。

前提：

内部类可以继承或实现一个外部类或者接口。

格式：

new 外部类名或者接口名(){覆盖类或者接口中的代码， (也可以自定义内容。)}

简单理解：

匿名内部类就是一个匿名子类对象，该对象把类和建立对象封装为一体。

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

代码：

abstract class AbsDemo
{
	abstract void show();
	}
class Outer
{
	int x = 3;
	public void function()
	{
		AbsDemo d = new AbsDemo()
		{
			int num = 9;
			void show()
			{
				System.out.println("num==="+num);
			}
			void abc()
			{
				System.out.println("haha");
			}
		};
		d.show();
		//d.abc();//编译失败;
	}
}
class InnerClassDemo4 
{
	public static void main(String[] args) 
	{
		new Outer().function();
	}
}

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

Crazy-J

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_面向对象

------- android培训、java培训、期待与您交流！ ---------- 一．对面向对象的理解面向对象是相对面向过程而言的。面向对象和面向过程都是一种思想。面向过程强调的是功能和行为。面向对象是将功能封装进对象，强调了具备功能的对象。举例：将大象装进冰箱里
复制链接

扫一扫

专栏目录