Java程序设计（面向对象）- 相关内容

访问修饰符

修饰符详解

抽象类

当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具体实现方式，那么这些方法都有具体的方法体。
但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。比如一个图形类应该有一个求周长的方法，但是不同的图形求周长的算法不一样。那该怎么办呢？
分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

package com.itxbj_01;
/*
 * abstract:关键字，用于修饰方法和类
 * 抽象方法：不同类的方法是相似，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，没有具体方法体的方法就是抽象方法
 * 抽象类：有抽象方法的类必须是抽象类
 * 
 * 注意：一个类继承了抽象类需要重写他所有的抽象方法,否则这个类就得是抽象类
 */
public class AbstractDemo {

}

abstract class Animal1 {
	public abstract void eat();
	
	//非抽象方法子类可以不重写
	public void run() {
		
	}
}

class Cat1 extends Animal1 {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
		
	}
	
	/*public void eat() {
		System.out.println("猫吃鱼");
	}*/
}

abstract class Dog1 extends Animal1 {
	/*public void eat() {
		System.out.println("狗吃屎");
	}*/
}

特点

抽象类的特点：

• 抽象方法只能在抽象类里面
• 抽象类和抽象方法必须被abstract修饰
• 抽象类不能创建对象（不能实例化）
• 抽象类中可以有非抽象的方法
• 抽象类和类的关系也是继承
• 一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
  例如：

package com.itxbj_01;
/*
 * 抽象类的特点：
 * 		抽象方法只能在抽象类里面
 * 		抽象类和抽象方法必须被abstract修饰
 * 		抽象类不能创建对象（不能实例化）
 * 		抽象类中可以有非抽象的方法
 * 		抽象类和类的关系也是继承
 * 		一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
 */
public class AbstractDemo2 {
	public static void main(String[] args) {
		//Animal a = new Animal();
	}
}

abstract class Animal2 {
	public abstract void eat();
	
	public void run() {
		
	}
}

class Cat2 extends Animal2 {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}

}

成员的特点

抽象类的成员特点：

• 成员变量
  可以有成员变量
  可以有常量
• 成员方法
  可以有抽象方法
  可以有非抽象方法
• 构造方法
  可以有构造方法的，需要对抽象类的成员变量进行初始化

例如：

package com.itxbj_01;
/*
 * 抽象类的成员特点：
 * 		成员变量
 * 			可以有成员变量
 * 			可以有常量
 * 		成员方法
 * 			可以有抽象方法
 * 			可以有非抽象方法
 * 		构造方法
 * 			可以有构造方法的，需要对抽象类的成员变量进行初始化
 * 
 * final:修饰类、成员变量、成员方法
 */
public class AbstractDemo3 {
	public static void main(String[] args) {
		Dog d = new Dog();
		d.barking();
	}
}

abstract class Animal {
	String name = "哮天犬";
	final int num = 10;
	
	public Animal() {
		System.out.println("我是抽象类的构造方法");
	}
	
	public abstract void eat();
	
	public void run() {}
}

class Dog extends Animal {
	public void barking() {
		System.out.println(name);
		System.out.println(num);
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}
}

细节

• 抽象类关键字abstract可以和哪些关键字共存?
  • private：
    私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
  • final:
    抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类
    抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写
  • static:
    抽象方法不能和static关键字共存,因为一旦加static我们就可以通过类名直接访问抽象方法,由于抽象方法没有方法体,没有任何意义,也不允许这样做
• 抽象类中是否可以不定义抽象方法?
  是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
• 抽象类是否有构造函数?
  有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化

接口

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

格式

与定义类的class不同，接口定义时需要使用interface关键字。
定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
定义格式：

public interface 接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}

使用

接口中的方法全是抽象方法,直接new接口来调用方法没有意义,Java也不允许这样干
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements
其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。
格式：

class 类 implements 接口 {
	重写接口中方法
}

在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
例如：

package com.itlishan_01;
/*
 * Java语言的继承是单一继承，一个子类只能有一个父类（一个儿子只能有一个亲爹）
 * Java语言给我们提供了一种机制，用于处理继承单一的局限性的，接口
 * 
 * 接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现，implements
 * interface
 * 
 * 格式：
 * 		interface 接口名 {
 * 
 * 		}
 * 
 */
public class InterfaceDemo {
	public static void main(String[] args) {
		BillGates gates = new BillGates();
		gates.code();
	}
}


class Boss {
	public void manage() {
		System.out.println("管理公司");
	}
}

class Programmer {
	public void code() {
		System.out.println("敲代码");
	}
}

//比尔盖茨
class BillGates extends Programmer {
	
}

成员的特点

1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解fnal关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
例如：

 package com.itlishan_01;
/*
 * 接口的成员特点：
 * 		只能有抽象方法
 * 		只能有常量
 * 		默认使用public&abstract修饰方法
 * 		只能使用public&abstract修饰方法
 * 		默认使用public static final来修饰成员变量
 * 
 * 建议：建议大家手动的给上默认修饰符
 * 
 * 注意：
 * 		接口不能创建对象（不能实例化）
 * 		类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法

 */
public class InterfaceDemo2 {
	public static void main(String[] args) {
		//Animal a = new Animal();
		//Animal.num;
	}
}


interface Animal {
	public static final int num = 10;
	
	public abstract void eat();
}

class Cat implements Animal {

	public void eat() {
		
	}
	
}

接口和类的关系

A:类与类之间:继承关系,一个类只能直接继承一个父类,但是支持多重继承
B:类与接口之间:只有实现关系,一个类可以实现多个接口
C:接口与接口之间:只有继承关系,一个接口可以继承多个接口
例如：

 package com.itlishan_01;
/*
 * 
 * 类与类：继承关系，单一继承，多层继承
 * 类与接口：实现关系，多实现
 * 接口与接口的关系：继承关系，多继承
 */
public class InterfaceDemo3 {
	public static void main(String[] args) {
		
	}
}

interface InterA extends InterB {
	public abstract void method();
}

interface InterB {
	public abstract void function();
}

interface InterC extends InterA {
	
}

class Demo implements InterC {

	@Override
	public void method() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void function() {
		// TODO Auto-generated method stub
		
	}
}

接口的思想

前面讲述了接口的代码体现，现在来学习接口的思想，接下里从生活中的例子进行说明。
举例：我们都知道电脑上留有很多个插口，而这些插口可以插入相应的设备，这些设备为什么能插在上面呢？主要原因是这些设备在生产的时候符合了这个插口的使用规则，否则将无法插入接口中，更无法使用。发现这个插口的出现让我们使用更多的设备。
接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（插在插口上的设备）。例如：笔记本使用这个规则（接口），电脑外围设备实现这个规则（接口）。
集合体系中大量使用接口

• Collection接口
  • List接口
    • ArrayList实现类
    • LinkedList实现类
  • Set接口

接口优点

1.类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，类与类之间是继承关系，java中的继承是单一继承，一个类只能有一个父类，打破了继承的局限性。
2.对外提供规则（USB接口）
3.降低了程序的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）

接口和抽象类的区别

1.共性：
不断的进行抽取，抽取出抽象的，没有具体实现的方法,都不能实例化（不能创建对象）
2.区别1: 与类的关系
(1)类与接口是实现关系，而且是多实现，一个类可以实现多个接口，类与抽象类是继承关系，Java中的继承是单一继承，多层继承，一个类只能继承一个父类，但是可以有爷爷类
(2)区别2： 成员

• 成员变量
  抽象类可以有成员变量，也可以有常量
  接口只能有常量，默认修饰符public static final
• 成员方法
  抽象类可以有抽象方法，也可以有非抽象方法
  接口只能有抽象方法，默认修饰符 public abstract
• 构造方法
  抽象类有构造方法，为子类提供
  接口没有构造方法
  例如：
  

package com.itlishan_02;
/* 	
 * 	篮球运动员和教练
	乒乓球运动员和教练
	现在篮球运动员和教练要出国访问,需要学习英语
	请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
 */
public class InterfaceTest {
	public static void main(String[] args) {
		//创建篮球运动员对象
		BasketBallPlayer bbp = new BasketBallPlayer();
		bbp.name = "女兆月日";
		bbp.age = 35;
		bbp.gender = "男";
		bbp.sleep();
		bbp.study();
		bbp.speak();
		System.out.println("-------------");
		//创建乒乓球教练对象
		PingpangCoach ppc = new PingpangCoach();
		ppc.name = "刘胖子";
		ppc.age = 40;
		ppc.gender = "男";
		ppc.sleep();
		ppc.teach();
		//ppc.speak();
		
		
		
	}
}

class Person {
	String name;//姓名
	int age;//年龄
	String gender;//性别
	
	//无参构造
	public Person() {}
	
	//有参构造
	public Person(String name,int age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//吃
	public void eat() {
		System.out.println("吃饭");
	}
	
	//睡
	public void sleep() {
		System.out.println("睡觉");
	}
}

//学习说英语
interface SpeakEnglish {
	public abstract void speak();
}

//运动员
abstract class Player extends Person {
	//学习
	public abstract void study();
}

//教练
abstract class Coach  extends Person {
	//教
	public abstract void teach();
}

//篮球运动员
class BasketBallPlayer extends Player  implements SpeakEnglish{

	@Override
	public void study() {
		System.out.println("学扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}
//乒乓球运动员
class PingpangPlayer extends Player {

	@Override
	public void study() {
		System.out.println("学抽球");
	}
	
}
//篮球教练
class BasketBallCoach extends Coach implements SpeakEnglish {

	@Override
	public void teach() {
		System.out.println("教扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}
//乒乓球教练
class PingpangCoach extends Coach {

	@Override
	public void teach() {
		System.out.println("教抽球");
	}
	
}

内部类

部类概述

• 什么是内部类
  将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

• 什么时候使用内部类
  在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

  class 汽车 { //外部类
  class 发动机 { //内部类
  }
  }

成员内部类

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

• 定义格式

    class 外部类 { 
    	修饰符 class 内部类 {
    		//其他代码
    }
    }

• 访问方式
  外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

例如：

  package com.itxbj_01;

 

/*
 * 成员内部类：
 * 		在类的成员位置，和成员变量以及成员方法所在的位置是一样的
 * 		在内部类当中，可以直接访问外部类的成员，包括私有成员
 */
public class InnerDemo {
	public static void main(String[] args) {
		//Outer o = new Outer();
		//o.method();
		
		
		Outer.Inner i = new Outer().new Inner();
		i.function();
		
		 
		
	}
}


class Outer {
	private int num = 10;
	
	public void method() {
		Inner i = new Inner();
		i.function();
	}
	
	class Inner {
		public void function() {
			System.out.println(num);
		}
	}
}

• 成员内部类
  成员内部类可以使用的修饰符:private,public,procted,final,static,abstract
  例如：

 package com.itxbj_01;
/*
 * 成员内部类的修饰符：
 * 		我们可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问
 * 		我们可以使用static修饰成员内部类，不用再创建外部类的对象了
 * 
 * 我们可以使用abstract,final修饰成员内部类
 */
public class InnerDemo2 {
	public static void main(String[] args) {
		//Outer2.Inner2 i;
		
		//Outer2.Inner2 i = new Outer2.Inner2();
		//i.function();
		
		Outer2.Inner2.function();
	}
}

class Outer2 {
	public void method() {
		Inner2 i = new Inner2();
	}
	static class Inner2 {
		public static void function() {
			System.out.println("function");
		}
	}
}

• 局部内部类
  局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
• 定义格式

 class 外部类 { 
修饰符 返回值类型 方法名(参数) {
 class 内部类 {
 //其他代码
  }
  }
}

• 访问方式
  在外部类方法中，创建内部类对象，进行访问

例如：

  package com.itxbj_02;
/*
 * 局部内部类
 * 		在方法内，出了方法之后就无法使用
 * 		
 * 
 */
public class InnerDemo3 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

class Outer {
	public void method() {
		int num = 10;
		
		class Inner {
			public void function() {
				System.out.println("function");
			}
		}
		
		Inner i = new Inner();
		i.function();
		
	}
	
	public void test() {
		//Inner i = new Inner();
		//System.out.println(num);
	}
}

匿名内部类

• 作用：匿名内部类是创建某个类型子类对象的快捷方式。
• 格式：

new 父类或接口(){
	//进行方法重写
};

例如：

//已经存在的父类：
public abstract class Person{
	public abstract void eat();
}
//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person  p = new Person(){
	public void eat() {
		System.out.println(“我吃了”);
}
};
//调用eat方法
p.eat();

使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：

new Person(){
	public void eat() {
		System.out.println(“我吃了”);
}
}.eat();

例如:

package com.itxbj_03;
/*
 * 匿名内部类:
 * 		可以把匿名内部类看成是一个没有名字的局部内部类
 * 		定义在方法当中
 * 		必须在定义匿名内部类的时候创建他的对象
 * 格式：
 * 		new 类/接口(){
 * 			如果是创建了继承这个类的子类对象，我们可以重写父类的方法
 * 			如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法
 * 		};
 * 原理：而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象
 * 	
 */
public class InnerDemo4 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}


interface Inner {
	public void function();
}

class Outer {
	public void method() {
		
		/*new Inner() {

			@Override
			public void function() {
				System.out.println("function");
			}
			
		}.function();;*/
		
		Inner i = new Inner() {

			@Override
			public void function() {
				System.out.println("function");
			}
			
		};
		
		i.function();
		i.function();
		
		
	}
}

例如:
匿名内部类作为参数传递

package com.itxbj_04;

public interface Animal {
   public abstract void eat();
}

package com.itxbj_04;

public class Cat implements Animal {

   @Override
   public void eat() {
   	System.out.println("猫吃鱼");
   }

}


package com.itxbj_04;

public class Dog implements Animal {

   @Override
   public void eat() {
   	System.out.println("狗啃骨头");
   }

}


package com.itxbj_04;
/*
* 匿名内部类的应用场景:
* 		作为参数进行传递
* 		
*      
*/
public class InnerDemo5 {
   public static void main(String[] args) {
   	 //method(new Dog());
   	 //method(new Cat());
   	
   
   	
   	method(
   			new Animal() {

   				@Override
   				public void eat() {
   					System.out.println("猫吃鱼");
   				}
   				
   			}	
   	);
   }	
   
   public static void method(Animal a) {
   	a.eat();
   }
}