JAVA学习笔记整理三(抽象类、接口、匿名类)

原创 2016年05月30日 20:50:06

抽象类与抽象方法:

1.    方法在本类中不实现,而是在子类中实现的方法,可以在该方法和类的声明中加入abstract修饰符,将该方法和类标记为抽象的

2.    包含一个抽象方法的类必须定义为抽象类

3.    抽象类和抽象方法都要使用abstract关键字声明

4.    抽象方法只需要声明而不需要实现

5.    抽象类必须被子类继承,子类(如果不是抽象类)必须覆写抽象类中的全部抽象方法

6.    构造方法、静态方法、私有方法、final方法不能被声明为抽象方法

public abstract class Abstract {
	public void test1() {//普通方法不需要被覆写,即使调用了抽象方法也不需要
		test2();
	};
	public abstract void test2();
	public abstract void test3();
}

class Abstract1 extends Abstract {//子类不是抽象类,必须覆写父类所有的抽象方法
	@Override
	public void test2() {
	}
	@Override
	public void test3() {
	}
}

abstract class Abtract2 extends Abstract {//子类是抽象类,可以选择性覆写父类的抽象方法
	@Override
	public void test2() {
	}
}

class Abtract extends Abtract2 {//普通方法再继承,则必须覆写父类没有覆写过的祖辈的抽象方法
	@Override
	public void test3() {
	}
}

7.    抽象类中允许存在构造方法,且子类对象实例化之前同样会默认调用父类中的无参构造

接口

1.    类似于类,是纯抽象类,不规定其实现,由全局常量和公共的抽象方法组成,也就是说接口中的所有方法都是抽象的,必须定义为public,即使不写也是public访问权限

2.    类只能继承一个父类,却可以实现多个接口

3.    接口可以继承另外的接口(可以不止一个)

public interface Interface {
	int a=1;//等价于:public static final int a = 1;
	void test();//等价于:public abstract void test();
}

interface Interface1{
	void test1();
}

interface Interface2 extends Interface,Interface1{//接口可以继承多个接口
	void test2();//接口可以不覆写继承的接口中的抽象方法
}

interface Interface3{
	void test3();
}

class Test implements Interface1{//实现接口
	@Override
	public void test1() {//实现接口中的抽象方法
	}
}

class Test1 implements Interface2{//实现接口
	@Override
	public void test() {//需要实现所有的抽象方法
	}
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
}

class Test2 implements Interface2,Interface3{//子类同时实现两个接口
	@Override
	public void test() {//需要覆写所继承的接口中的所有抽象方法
	}
	@Override
	public void test1() {
	}
	@Override
	public void test3() {
	}
	@Override
	public void test2() {
	}
}

abstract class Test3 implements Interface2,Interface3{//抽象类实现接口
	@Override
	public void test2() {//选择性覆写所继承接口中的抽象方法
	}
}

class Test4 extends Test3{//继承抽象类
	@Override
	public void test() {//需要实现父类没有继承过的祖类的抽象方法
	}
	@Override
	public void test1() {
	}
	@Override
	public void test3() {
	}
}


内部类

1.    在一个类或方法中定义另外一个类,这个类就叫做内部类或内置类,内部类对象可以随意的访问外部类中所有的成员

2.    在方法中定义的内部类,如果要访问方法中定义的本地变量或方法的参数,则变量必须被声明final

3.    内部类可以声明为private或protected,也声明为abstract或final;但如果声明为static的,就不能再使用外部类的非static的成员变量和非static的成员方法

4.    在外部访问一个类的内部类,首先要找到外部类的实例化对象,再通过外部类的实例化对象去实例化内部类的对象   

public class OuterClass {
	Animal animal;
	static int a=1;
	int b=2;
	public OuterClass(){//构造方法
		animal=new Dog();//实例化子类
	}
	public void test(){
//		OuterClass oc = new OuterClass();
//		oc.speak(animal);//不能调用外部类
		new InnerClass().speak();//可以调用内部类的方法
		
		int x=1;
		final int y=2;
		class InnerClass2{//方法中的内部类
			public void test(final int m){
//				int z=x+1;//在方法中定义的内部类,如果要访问方法中定义的本地变量或方法的参数,则变量必须被声明final
				int v=y+1;
				int d=y+m;
			}
		}
	}

public class InnerClass{//内部类
		public void speak() {
			animal.speak();
		}
//		public static void test(){// 非static的内部类中的成员不能声明为static的,只有在顶层类或static的内部类中才可声明static成员
//		};
	}
	public static class InnerClass1{
		public void test(){
//			animal.speak();// 内部类可以声明为static的,此时就不能再使用外部类的非static的成员变量和非static的成员方法
			int c=a+1;
//			int d=b+1;
		}
	}
}

abstract class Animal {//抽象外部类Animal
	public abstract void speak();
}

class Dog extends Animal{//继承抽象类
	@Override
	public void speak() {
		System.out.println("汪汪汪");
	}
}

class OuterClass1{//外部类
	public void speak(Animal animal) {
		animal.speak();
	}
	//在外部访问一个类的内部类
	OuterClass out =new OuterClass();//首先实例化外部类对象
	OuterClass.InnerClass in = out.new InnerClass();//通过外部类的实例化对象去实例化内部类的对象
}

匿名内部类:没有名字的类,这个类在定义的时候被实现

public class InnerClassTest {
	public static void main(String[] args) {
		new X().fun1();//实例化X类对象并调用fun1方法
	}
}

interface I{//定义接口I
	public void printInfo();//定义抽象方法
}

class X{//定义X类
	public void fun1(){
		this.fun2(new I(){//匿名内部类
			public void printInfo(){//实现接口中的抽象方法
				System.out.println("Hello World!");
			}
		});
	}
	public void fun2(I a){//接收接口实例
		a.printInfo();//调用接口方法
	}
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

JAVA-接口 抽象类 内部类 匿名类

接口中所有属性是Public static final,方法都是public. 访问修饰符则必须是public 接口也可扩展另一个接口,相似于类的继承,关键字extends http://...

Java内部抽象类的匿名类初始化

说在前面的话,以前写过一次这个变态代码,后来重构,把那个new的语法简化了,最近又要整,差点都想不起来了,留个文档把 1、下面这个案例更变态,抽象类还有一个个泛型类:首先内部抽象类的定义:/* *...
  • dipolar
  • dipolar
  • 2016年08月24日 16:42
  • 767

NO8.java笔记【面向对象、抽象类、abstract、接口、interface、多态 、内部类、匿名内部类、异常、Object类】

/** 面向过程:1.打开冰箱 2.存储大象 3.关上冰箱。强调的过程(动作、功能、函数)。 面向对象:强调的是对象(实体)。冰箱【1.打开 2.存储 3.关闭】 调用 特点:1.面向对象就是一种常见...

Java之学习笔记(19)-----------包装类和匿名类

目录(?)[+] 包装类(Wrapper Class)   包装类是针对于原生数据类型的包装。   因为有8个原生数据类型,所以对应有8个包装类。   所有的包装类(8个)都位于java....

01-java学习笔记【接口与抽象类】

这些是我自己的理解加上网上优秀的分享总结出来的。 抽象类是用来捕捉子类的通用特性的 。它不能被实例化,只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。 接口是抽象方法的集合。如果一个类实...

JAVA抽象类接口学习笔记

抽象类什么是抽象类JAVA允许在类中只声明方法而不提供方法的实现。 这种只有声明而没有方法体的方法称为抽象方法,而包含一个或多个抽象方法的类称为抽象类。抽象(abstract)类: 抽象类是以ab...

java学习笔记-抽象类abstract与接口interface

/** * abstract 是修饰符可以修饰类,函数 * 当我们在多个类有相同功能的时候,而功能的主体不同,我们应该向上抽取只抽取功能的定义不抽取功能的主体 * 抽象类的特点: * 1.抽象...

JAVA学习笔记15——抽象类+接口

最近在看JAVA教学的视频,觉得老师讲的很好,同时借用源代码还有笔记来撰写本系列博客,记录自己的学习内容,同时也供看到的人学习。 本篇讲抽象类(abstract)和接口(interface)的主要内...

Java学习笔记---抽象类和接口

14.2 抽象类一个父类设计的非常抽象,以至于它都没有任何具体的实例.这样的类称为抽象类.抽象类和常规类很像,但是不能用new操作符创建它的实例.抽象方法只有定义而没有实现.它的实现由子类提供.一个包...
  • Hareric
  • Hareric
  • 2015年11月23日 19:26
  • 327

Bravo!Java学习笔记(1)---接口、抽象类、对象克隆、内部类

接口接口是为了实现java的“对修改封闭,对扩展开放 ”原则,某个对象声明了某个接口类方法,它便具备接口的功能,把功能部分封装出来,自然很好扩展。 例如,某个类要使用排序,但排序一定有比较大小。于是...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA学习笔记整理三(抽象类、接口、匿名类)
举报原因:
原因补充:

(最多只允许输入30个字)