Java第七章总结

两块钱一斤

已于 2022-04-30 15:21:06 修改

阅读量143

点赞数

文章标签： java 开发语言 eclipse

于 2022-04-30 00:36:53 首次发布

本文链接：https://blog.csdn.net/X18930/article/details/124506725

版权

7.1类的封装

封装将类的某些信息隐藏在类内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类。

封装的特点：
只能通过规定的方法访问数据。
隐藏类的实例细节，方便修改和实现。
实现封装的具体步骤如下：

修改属性的可见性来限制对属性的访问，一般设为 private。
为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

public class Restaurant1 {//创建一个类
 
	public static void main(String[] args) {//主方法
		String cookName="Tom Cruise";//厨师的名字叫Tom Cruise
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		System.out.println(cookName+"切葱花");//输出
		System.out.println(cookName+"洗蔬菜");//输出
		System.out.println(cookName+"开始烹饪"+"香辣肉丝");//输出
		System.out.println("**请问厨师叫什么名字？***");//输出
		System.out.println(cookName);//输出
		System.out.println("请让厨师给我切一点葱花。***");//输出
		System.out.println(cookName+"切葱花");//输出
	}
 
}

public class Restaurant2 {//创建一个类
 
	public static void main(String[] args) {//主方法
		Cook1 cook=new Cook1();//创建厨师类的对象
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		cook.cooking("香辣肉丝");//厨师烹饪香辣肉丝
		System.out.println("**你们的厨师叫什么名字？***");//输出
		System.out.println(cook.name);//厨师回答自己的名字
		System.out.println("**请让厨师给我切一点葱花。***");//输出
		cook.cutOnion();//厨师去切葱花
 
	}
 
}
class Cook1{//创建类
	String name;//厨师的名字
	public Cook1(){//定义一个方法
		this.name="Tom Cruise";//厨师的名字叫Tom Cruise
	}
	void cutOnion(){//厨师切葱花
		System.out.println(name+"切葱花");//输出信息
	}
	void washVegetables(){//厨师洗蔬菜
		System.out.println(name+"洗蔬菜");//输出信息
	}
	void cooking(String dish){//厨师烹饪顾客点的菜
		washVegetables();//调用洗蔬菜方法
		cutOnion();//调用切葱花方法
		System.out.println(name+"开始烹饪"+dish);//输出信息
	}
}

通过封装，实现了对属性的数据访问限制，满足了年龄的条件。在属性的赋值方法中可以对属性进行限制操作，从而给类中的属性赋予合理的值，并通过取值方法获取类中属性的值（也可以直接调用类中的属性名称来获取属性值）。

public class Restaurant4 {//创建类
private Cook2 cook=new Cook2();//餐厅封装的厨师类
public void takeOlder(String dish){//下单	Restaurant2 a=new Restaurant2();//创建一个对象
	cook.cooking(dish);//通知厨师做菜
	System.out.println("您的菜好了，请慢用。");//输出信息
}
public String saySorry(){//拒绝顾客请求
	return"抱歉，餐厅不提供此项服务。";//返回字符串
	
}
	public static void main(String[] args) {//主方法
		Restaurant4 water=new Restaurant4();//创建餐厅对象，为顾客提供服务
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		water.takeOlder("香辣肉丝");//服务员给顾客下单
		System.out.println("**你们的厨师叫什么名字？***");//输出信息
		System.out.println(water.saySorry());//服务员给顾客善意的答复
		System.out.println("**请让厨师给我切一点葱花。***");//输出信息
		System.out.println(water.saySorry());//服务员给顾客善意的答复
	}
 
}

7.2类的继承

继承是面向对象的三大特征之一。继承和现实生活中的“继承”的相似之处是保留一些父辈的特性，从而减少代码冗余，提高程序运行效率。

继承其基本思想是基于某父类的扩展，制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类中的某些方法。

1.extends关键字

在java中，让一个类继承另一个类，用extends关键字

child extends parents//子类继承父类

注意：java中的类只支持单继承，即一个子类只能继承一个父类，类似下面的代码是错误的：

child extends parents1,parent2{
//错误的继承语法
}

class Computer{//父类
	String screen="液晶显示屏";
	void startup(){//开机方法
		System.out.println("电脑正在开机，请等待...");//输出
	}
}
 
public class Pad extends Computer{//创建一个类并继承父类
String battery="5000毫安电池";//子类独有的属性
	public static void main(String[] args) {//主方法
		Computer pc=new Computer();//电脑类
		System.out.println("computer的屏幕是:"+pc.screen);//输出
		pc.startup();//调用父类方法
		Pad ipad=new Pad();//平板电脑类
		System.out.println("pad的屏幕是："+ipad.screen);//子类可以直接使用父类属性
		System.out.println("pad的屏幕是："+ipad.battery);//子类独有的属性
		ipad.startup();//子类可以直接使用父类方法
 
	}
 
}

从这个结果可以看出，Pad类继承了Computer类之后，虽然没有定义任何成员方法，但仍然可以调用父类的方法，这个方法就是从父类那里继承过来的。

2.方法的重写

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。

重写的实现

注意：当重写父类的方法时，修改方法的修饰权限只能从小的范围到大的范围改变，例如，父类中的doSomething()方法的修饰权限为protected,继承后子类中的方法doSomething()的修饰权限只能修改为public,不能修改为private。

class Computer2{//父类：电脑
	void showPicture(){//定义一个方法
		System.out.println("鼠标单击");//输出信息
	}
}
public class Pad2 extends Computer2 {//创建一个类并继承父类
void showPicture(){//重写父类的方法
	System.out.println("手指点击触摸屏");//输出信息
}
	public static void main(String[] args) {//主方法
		Computer2 pc=new Computer2();//电脑类
		System.out.print("pc打开图片：");//输出信息
		pc.showPicture();//调用方法
		Pad2 ipad=new Pad2();//平板电脑类
		System.out.print("ipad打开图片：");//输出信息
		ipad.showPicture();//重写父类方法
		Computer2 computerpad=new Pad2();//父类声明，子类实现
		System.out.print("computerpad打开图片：");//输出信息
		computerpad.showPicture();//调用父类方法，实现子类重写的逻辑
	}
 
}

注意：在java语言中，一个类只可以有一个父类！

super关键字

super关键字可以调用父类的方法和属性，它的使用方法和this关键字相似。但this关键字代表本类的对象，super关键字带调用的是父类的方法

super.property;//调用父类的属性
super.method();//调用父类的方法

class Computer3{//父类：电脑
	String sayHello(){//定义一个方法
		return"欢迎使用";//返回一个字符串
	
	}
	
}
public class Pad3 extends Computer3 {//子类：平板电脑
	String sayHello(){//重写方法
		 return super.sayHello()+"平板电脑";//调用父类方法，在其结果后添加字符串
	}
 
	public static void main(String[] args) {//主方法
Computer3 pc=new Computer3();//电脑类
System.out.println(pc.sayHello());//调用父类的方法并输出
Pad3 ipad=new Pad3();//平板电脑类
System.out.println(ipad.sayHello());//调用子类的方法并输出
 
	}
 
}

注意：如果在子类构造方法中使用类似super()构造方法，其他初始化代码只能写在super()之后，不能写在前面，否则会报错。

3. Object类——所有类的父类

在java中，所有的类都直接或间接继承了java.lang.Object类。Object类是所有类的父类，是java类层中的最高层类。

注意：Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName ()方法可以取得类的名称。

语法如下：

getClass().getName();//调用getClass()里的getName()方法

toString()方法

toString()方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString()方法。

public class ObjectInstance {创建类
public String toString(){//重写toString()方法
	return "在"+getClass().getName()+"类中重写toString()方法";//返回值
}
	public static void main(String[] args) {//主方法
		System.out.println(new ObjectInstance());//调用方法并输出，打印本类对象
	}
 
}

equals()方法

比较两个对象的实际内容。

class V{//自定义类V
	
}
public class OverWriteEquals {//创建一个方法
 
	public static void main(String[] args) {//主方法
		String s1="123";//实例化两个对象，内容相同
		String s2="123";//实例化对象
		System.out.println(s1.equals(s2));//使用equals()方法
		V v1=new V();//实例化两个V类对象
		V v2=new V();//实例化对象
		System.out.println(v1.equals(v2));//使用equals()方法
	}
 
}

7.3类的多态

类的多态性指“一种定义，多种实现”，类的多态性可以从两方面体现：方法的重载，类的上下转型。

1.方法的重载

重载（不需要继承）：返回参数不同、传入参数不同、方法名相同

public class OverLoadTest {//定义一个方法
	public static int add(int a){//定义一个方法并传入一个int型参数
		return a;//返回一个整型值
	}
	public static int add(int a,int b){//定义一个方法并传入两个参数
		return a+b;//返回a+b的值
	}
	public static double add(double a,double b){//定义一个方法并传入两个参数
		return a+b;//返回a+b的值
	}
	public static int add(int a,double b){//定义一个方法并传入两个参数
		return (int)(a+b);//返回a+b的值，同时利用强制转换成int型
	}
	public static int add(double a,int b){//定义一个方法并传入两个参数
		return (int)(a+b);//返回a+b的值，同时利用强制转换成int型
	}
	public static int add(int...a){//定义一个不定长参数方法
		int s=0;//定义一个int型变量并赋予初值
		for(int i=0;i<a.length;i++){//遍历数组
			s+=a[i];//总计
		}
		return s;//返回s的值
	}
	public static void main(String[] args) {//主方法
		System.out.println("调用add(int)方法："+add(1));//调用方法并输出
		System.out.println("调用add(int,int)方法："+add(1,2));//调用方法并输出
		System.out.println("调用add(double,double)方法："+add(2.1,3.3));//调用方法并输出
		System.out.println("调用add(int a,double b)方法："+add(1,3.3));//调用方法并输出
		System.out.println("调用add(double a,int b)方法："+add(2.1,3));//调用方法并输出
		System.out.println("调用add(int...a)不定长参数方法："+add(1,2,3,4,5,6,7,8,9));//调用方法并输出
		System.out.println("调用add(int...a)不定长参数方法："+add(2,3,4 ));//调用方法并输出
 
	}
 
}

注意：虽然在方法的重载中可以使两个方法的返回类型不同，但只有返回类型不同不足以区分两个方法的重载，还需要通过参数的个数以及参数的类型来设置。

2.向上转型

子类转变成父类类型

class Quadrangle{//四边形类
public static void draw(Quadrangle q){//四边形类中的方法
//SomeSentence
}
}
public class Parallelogram extends Quadrangle{//平行四边形类，继承了四边形类
public static void main(String args[]){//主方法
Parallelogram p=new Parallelogram();//实例化平行四边形类对象引用
draw(p);//调用父类方法
}
}

3.向下转型

父类转变成子类使用强制转换

class Quadrangle{//父类
	public static void draw(Quadrangle q){//父类方法
		//SomeSentence
	}
}
public class Parallelogram extends Quadrangle {//子类继承父类
 
	public static void main(String[] args) {//主方法
	draw(new Parallelogram());//调用方法并传入子类对象
	Quadrangle q=new Parallelogram();//将平行四边形对象看作是四边形对象，称为向上转型操作
	Parallelogram p=q;//向下转型
 
	}
 
}

4.instanceof关键字

当在程序中执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生classcastException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例。

myobject instanceof ExampleClass//判断是否为该类的实例对象

myobject:某类的对象引用。

ExampleClass:某个类

使用instanceof操作符的表达式返回值为布尔值。

class Quadrangle{//类名
	public static void draw(Quadrangle q){//构造一个方法并传入一个参数
		//SomeSentence
	}
}
class Square extends Quadrangle{//构造一个类并继承另一个类
	//SomeSentence
}
class Anything{//构造一个类
	//SomeSentence
}
public class Parallelogram extends Quadrangle {//创建一个类并继承另一个类
 
	public static void main(String[] args) {//主方法
		Quadrangle q=new Quadrangle();//创建一个对象
		if(q instanceof Parallelogram){//判断该对象是否属于该类
			Parallelogram p=(Parallelogram)q;//进行强制转换
		}
		if(q instanceof  Square){//判断该对象是否属于该类
			Square s=(Square) q;//进行强制转换
		}
		System.out.println(q instanceof  Anything );//输出信息
	}
 
}

7.4抽象类与接口

1.抽象类与抽象方法

在java中设置抽象类不可以实例化对象。

[权限修饰符] abstract class 类名{
类体
}

使用abstract关键字定义的类称为抽象类，而使用abstract关键字定义的方法称为抽象方法。

[权限修饰符]abstract 方法返回值类型 方法名（参数列表）;

从上面的语法可以看出，抽象方法是直接以分号结尾的，它没有方法体，抽象方法本身没有任何意义。除非它被重写，而承载这个抽象方法的抽象类必须被继承。

注意：构造方法不能定义为抽象方法

public abstract class Market {//创建类
public String name;//商场名称
public String goods;//商品名称
public abstract void shop();//抽象方法，用来输出信息
	
 
}

public class TaobaoMarket extends Market {//创建类并继承商场类
 
	@Override
	public void shop() {//重写方法
		// TODO Auto-generated method stub
		System.out.println(name+"网购"+goods);	//输出信息	
	}
 
}

public class GoShopping {//类名
 
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
Market market=new WallMarket();//向上转型
market.name="沃尔玛";//赋值
market.goods="七匹狼西服";//赋值
market.shop();//调用方法
market=new TaobaoMarket();//创建一个对象
market.name="淘宝";//赋值
market.goods="韩都衣舍花裙";//赋值
market.shop();//调用方法
	}
 
}

使用抽象类和抽象方法时，需要遵守以下原则：

1、在抽象类中，可以包含抽象方法，也可以不包含抽方法，但是包含了抽象方法的类必须被定义为抽象类。

2、抽象类不能直接实例化，即使抽象类中没声明抽象方法，也不能实例化。

3、抽象类被继承后，子类需要实现其中所有的抽象方法。

4、如果继承抽象类的子类也被声明为抽象类，则可以不用实现父类中所有的抽象方法。

2.接口的声明及实现

接口是抽象类的延申，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。即全部都是抽象方法。

[修饰符]interface 接口名[extends 父接口名列表]{
[public] [static] [final]常量;
[public] [abstract] 方法;
}

一个类实现一个接口可以使用implements关键字

public class Parallelogram extends Quadrangle implements drawTest{
....//
}

说明：在接口中定义的任何变量都自动是static和final的，因此，在接口中定义变量时，必须进行初始化，而且，实现接口的子类不能对接口的变量重新赋值。

interface drawTest{//定义接口
	public void draw();//定义方法
}
class ParallelogramgleUseInterface implements drawTest{//创建类并继承接口
 
	@Override
	public void draw() {//重写方法
		// TODO Auto-generated method stub
		System.out.println("平行四边形.draw()");//输出
	}
	
}
class SquareUseInterface implements drawTest{//创建类并继承接口
 
	@Override
	public void draw() {//重写方法
		// TODO Auto-generated method stub
		System.out.println("正方形.draw()");//输出
	}
	
}
public class QuadrangleUseInterface {//创建类
 
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		drawTest[]d={//定义一个一维数组
				new SquareUseInterface(),new ParallelogramgleUseInterface()};//向上转型
		for(int i=0;i<d.length;i++){//遍历数组
			d[i].draw();//输出元素
		}
 
	}
 
}

说明：由于接口中的方法都是抽象的，因此，当子类实现接口时，必须实现接口中所有的方法。

3.多重继承

在java中不允许多重继承，但使用接口就可以实现多重继承，因为一个类可以同时实现多个接口。

class 类名 implements 接口1,接口2,接口3...接口n

public interface IFather {//定义一个接口
void smoking();//抽烟的方法
void goFishing();//钓鱼方法
}

public interface IMother {//定义一个接口
void watchTV();//看电视的方法
void cooking();//做饭的方法
}

public class Me implements IFather,IMother {//创建类并继承两个接口
 
	
	public void watchTV() {//重写方法
		// TODO Auto-generated method stub
		System.out.println("我喜欢看电视");//输出信息
	}
 
 
	public void cooking() {//重写方法
		// TODO Auto-generated method stub
		System.out.println("我喜欢做饭");//输出信息
	}
 
	
	public void smoking() {//重写方法
		// TODO Auto-generated method stub
		System.out.println("我喜欢抽烟");//输出信息
	}
 
	@Override
	public void goFishing() {//重写方法
		// TODO Auto-generated method stub
		System.out.println("我喜欢钓鱼");//输出信息
	}
 
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
IFather father=new Me();//进行向上转型
System.out.println("爸爸的爱好：");//输出信息
father.smoking();//调用方法
father.goFishing();//调用方法
IMother mather=new Me();//进行向上转型
System.out.println("妈妈的爱好：");//输出信息
mather.cooking();//调用方法
mather.watchTV();//调用方法
	}
 
 
}

注意：使用多重继承时，可能出现变量或方法名冲突的情况，解决该问题时，如果变量冲突，则需要明确指定变量的接口，即通过”接口名.变量“实现；如果出现方法冲突时，则只要实现一个方法即可。

4. 区分抽象类和接口：

7.5访问控制

1. 访问控制符：

注意：声明类时，如果不使用public修饰符设置类的权限，则默认该类为default修饰使用访问控制符时，需要遵循以下原则。
(1)大部分顶级类都使用public修饰；
(2)如果某个类主要用作其他类的父类，该类中包含的大部分方法只是希望被其子类重而不想被外界直接调用，则应该使用protected修饰；
(3)类中的绝大部分属性都应该使用private修饰，除非一些static或者类似全局变量的加才考虑使用public修饰；
(4)当定义的方法只是用于辅助实现该类的其他方法(即工具方法)，应该使用private(5)希望允许其他类自由调用的方法应该使用public修饰.

2.Java类包

在类中定义包名的语法如下：

package包名1[.包名2[.包名3...]]；

3. final关键字

定义为final的类不能被继承。

final class 类名{}

final class FinalClass {//创建类
	int a=3;//定义一个整型变量并赋予初值
	void doit(){//定义一个方法
	}
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
FinalClass f=new FinalClass();//创建对象
f.a++;//调用成员变量并进行自增运算
System.out.println(f.a);//输出
	}
 
}

final方法

class Parents{//类名
	private final void doit(){//方法
		System.out.println("父类.doit()");//输出
	}
	final void doit2(){//方法
		System.out.println("父类.doit2()");//输出
	}
	public void doit3(){//方法
		System.out.println("父类.doit3()");//输出
	}
}
class Sub extends Parents{//创建类并继承父类
	public final void doit(){//方法
		System.out.println("子类.doit()");//输出
	}
//	final void doit2(){//方法
	//	System.out.println("父类.doit2()");
		
	//}
	public void doit3(){//方法
		System.out.println("子类.doit3()");//输出
	}
}
public class FinalMethod {//创建类
 
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
Sub s=new Sub();//创建对象
s.doit();//调用方法
Parents p=s;//执行向上转型操作
//p.doit();//不能调用private方法
p.doit2();//调用方法
p.doit3();//调用方法
	}
 
}

final变量

final关键字可用于变量声明，一旦该变量被设定，就不可以再改变该量的值。通常，有final定义的变量为常量

import java.util.Random;//导入random方法
import static java.lang.System.out;//导入方法
 
class Test{//类名
	int i=0;//定义一个整型变量并初始化
}
public class FinalData {//创建类
static Random rand=new Random();//创建对象
private final int VALUE_1=9;//定义常量
private static final int VALUE_2=10;//定义常量
private  final Test test=new Test();//创建对象
private Test test2=new Test();//创建对象
private final int[]a={1,2,3,4,5,6};//定义一个一维数组并赋值
private final int i4=rand.nextInt(20);//定义变量并随即赋值
private static final int i5=rand.nextInt(20);//定义变量随机赋值
public String toString(){//使用toString()方法
	return i4+" "+i5+" ";//返回字符串
}
	public static void main(String[] args) {//主方法
	FinalData data=new FinalData();//创建对象
	data.test=new Test();//创建对象
	data.VALUE_2;//调用变量
	data.test2=new Test();//向上转型
for(int i=0;i<data.a.length;i++){//遍历数组
	//a[i]=9;
	//不能对定义为final的数组赋值
}
out.println(data);//输出
out.println("data2");//输出
out.println(new FinalData());//输出
out.println(data);//输出
	}
}

import java.util.Random;//导入Random方法
import static java.lang.System.out;//导入方法
 
public class FinalStaticData {//创建类
private static Random rand=new Random();//实例化一个Random类对象
private final int a1=rand.nextInt(10);//随机赋值
private static final int a2=rand.nextInt(10);//随机赋值
 
	public static void main(String[] args) {//主方法
		FinalStaticData fdata=new FinalStaticData();//创建对象
		out.println("重新实例化对象调用a1的值："+fdata.a1);//输出
		out.println("重新实例化对象调用a1的值："+fdata.a2);//输出
		FinalStaticData fdata2=new FinalStaticData();//创建对象
		out.println("重新实例化对象调用a1的值："+fdata2.a1);//输出
		out.println("重新实例化对象调用a2的值："+fdata2.a2);//输出
	}
 
}

7.6 内部类

1.成员内部类

语法如下：

public class OuterClass{//外部类
private class InnerClass{//内部类
//...
}
}

在内部类可以随意使用外部类的成员方法以及成员变量。

public class OuterClass {//创建类
innerClass in=new innerClass();//创建对象
public void ouf(){//方法
	
}
class innerClass{//类名
	innerClass(){//方法
		
	}
	public void inf(){//方法
	}
	int y=0;//定义变量
	}
	public innerClass doit(){//方法
		//y=4;
		in.y=4;//调用变量
		return new innerClass();//返回对象
	}
 
	public static void main(String[] args) {//主方法
		OuterClass out=new OuterClass();//创建对象
		OuterClass.innerClass in=out.doit();//调用方法
		OuterClass.innerClass in2=out.new innerClass();//向上转型
 
	}
 
}

内部类向上转型为接口

interface OutInterface{//定义接口
	public void f();//抽象方法
}
public class InterfaceInner {//创建类
 
	public static void main(String[] args) {主方法
		OuterClass2 out=new OuterClass2();//创建对象
		OutInterface outinter=out.doit();//调用方法
		outinter.f();//调用方法
	}
}
class OuterClass2{//类名
	private class InnerClass implements OutInterface{//继承接口
InnerClass(String s){//重写方法
	System.out.println(s);//输出
}
		
		public void f() {//重写方法
			System.out.println("访问内部类中的f()方法");//输出信息
		}
		
	}
	public OutInterface doit(){//重写方法
		return new InnerClass("访问内部类构造方法");//输出信息
		
	}
}

使用this关键字获取内部类与外部类的引用：

public class TheSameName {//类名
private int x;//定义整型变量
private class Inner{//定义方法
	private int x=9;//定义整型变量并初始化
	public void doit(int x){//方法
		x++;//自增运算
		this.x++;//自增运算
		TheSameName.this.x++;//自增运算
	}
}
}

2.局部内部类

内部类不仅可以在类中进行定义，也可以在类的局部位置定义。

interface OutInterface2{//定义接口
	
}
	
 class OuterClass3 {//类名
public OutInterface2 doit(final String x){//方法
	class InnerClass2 implements OutInterface2(String s){类继承
		InnerClass2(String s){//内部类
			
		s=x;//赋值
		System.out.println(s);//输出
	}
	
}
	return new InnerClass2("doit");//返回值
}
}

3.匿名内部类

interface OutInterface2{//定义一个接口
}
class OuterClass4{//创建类
public OutInterface2 doit(){//定义方法
return new OutInterface2(){//返回值
private int i=0;//定义变量并初始化
public int getValue(){//方法
return i;//返回值
}
};
}
}

使用匿名内部类时应该遵循以下原则：
(1)匿名类没有构造方法；
(2)匿名类不能定义静态的成员；
(3)匿名类不能用private、public、protected、static、final、abstract等修饰；
(4)只可以创建一个匿名类实例。

4.静态内部类

用static 修饰的类静态内部类具有以下两个特点：

(1)如果创建静态内部类的对象，不需要创建其外部类的对象；
(2)不能从静态内部类的对象中访问非静态外部类的对象。

public class StaticInnerClass {//创建类
	int x=100;//定义一个整型变量并初始化
	static class Inner{//内部类
	void doitInner(){//方法
	//System. out. printin("外部类"+x);//输出
	}
	public static void main(String args[]){//主方法
	
	
	System. out. println();//换行
	}
}
}

5.内部类的继承

public class OutputInnerClass extends ClassA.ClassB{//创建类并继承另一个类
public OutputInnerClass(ClassA a){//方法
a.super();//调用父类构造方法
}
}
class ClassA{//外部类
class ClassB{//内部类
}
}

7.7 小结

通过本章的学习，读者可以了解继承与多态的机制，掌握重载、类型转换等技术。学会使用接口与抽象类，从而对继承和多态有一个比较深入的了解。

两块钱一斤

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java第七章总结

目录7.1类的封装7.2类的继承1.extends关键字2.方法的重写3.Object类——所有类的父类7.3类的多态1.方法的重载2.向上转型3.向下转型4.instanceof关键字7.4抽象类与接口1.抽象类与抽象方法2.接口的声明及实现3.多重继承4. 区分抽象类和接口：7.5访问控制1.访问控制符：2.Java类包3. final关键字7.6 内部类1.成员内部类2.局部内...
复制链接

扫一扫