Java零基础学习记录11（抽象方法、接口、内部类）

最新推荐文章于 2024-08-11 20:24:14 发布

一个垃圾程序员的咆哮

最新推荐文章于 2024-08-11 20:24:14 发布

阅读量128

点赞数

分类专栏：零基础学Java 文章标签：抽象类接口内部类详解

本文链接：https://blog.csdn.net/qq_39316309/article/details/96024255

版权

零基础学Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1. 抽象类和抽象方法

**
(1) 简述抽象方法的特征

1.抽象方法中可有成员变量、成员方法、静态方法、final所修饰的方法、abstract所修饰的方法。

2.抽象方法只能声明在抽象类中（含有抽象方法的类必须是抽象类），抽象方法不能有方法体。

3.抽象方法必须被子类实现。

如果子类不想实现父类的抽象方法，子类也必须是抽象类。

5.抽象类中可以包含0个或多个抽象方法。

package Abstract;
public abstract class Animal {

	private String name;// 抽象类中可以有private所修饰的成员变量
	public static final int age = 1;// 抽象类可以有final所修饰的成员变量

	public Animal() { // 抽象类中有构造方法，但是不能创建实例，只能由子类的构造方法调用

	}

	public static void see() {// 抽象类中可以有静态方法

		System.out.println("see");
	}

	public void run() {// 抽象类中可以有成员方法
		System.out.println("run");
	}

	public abstract void shout();// 抽象类中可以有0个或者多个抽象方法，但抽象方法不能有方法体

}


class Dog extends Animal{        //Dog类

	@Override
	public void shout() {      //子类必须实现父类的抽象方法，不然该类也必须定义为子类
		System.out.println("汪汪汪！");
	}
	
}

class Cat extends Animal{      //Cat类

	@Override
	public void shout() {
		System.out.println("喵喵喵！");
		
	}
	
}

(2) 什么情况下使用抽象方法?

答：通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。（程序的可扩展性和可维护性）。

父类的名字比较抽象，创建对象无意义时使用。

例如：动物类（Animal类）。每种动物都能叫（方法），但是各自叫的声音都不一样，所以，Animal类可以定义为一个抽象类。使用子类分别实现叫的方法。

2. 接口的详解

**
(1) 接口中可以包含哪些内容？**

1.方法，只能由public abstract修饰（如果没加，编译器会自动添加）。jdk1.7前接口中只能有抽象方法。jdk1.8以后可以有非抽象方法（但必须使用default或者static修饰）。

2.属性，只能由public static final（如果没加，编译器会自动加）修饰的常量。

3.接口中不允许有构造方法，因为接口不是类。

(2) 接口和类的关系？

类去实现接口中的抽象方法，实现关系，使用关键字implements

2.一个类存在继承关系，又存在实现关系？extends在前？还是implements在前？

继承—>父子关系—>亲爹

实现—>实现关系—>干爹

所以继承在前，实现在后。

3. 如果子类与接口中有完全相同的方法（一模一样），子类/实现类所实现的是父类的？还是接口的？

答：父类优先于接口，子类实现的是父类中的方法。

** 4. 如果父类中与接口中有同名的方法，对子类/实现类有什么要求呢?

**
答：如果父类与接口中的方法名字相同，形参列表不同，在子类/实现类中可以构成重载，可以有。如果父类与接口中有同名的方法，形参列表相同，返回值不同，在子类中不构成重载，所以不允许。

5. 使用接口的意义

**
(1) 接口有哪些特征？

1.传递性

2接口的多继承.

(2) 使用接口实现多态的步骤？

编写接口。
实现类实现接口中的方法。
接口（类型） new实现类的对象。

(3) 什么情况使用接口？

答：当一些实例不属于同一类别，但是都具有相同的能力，不能将这些实例抽象成同一个类时使用接口。接口体现的是一种能力。

例如：鸟、飞机、火箭、导弹等。都具有飞行的能力，但是都属于不同的类别。所以可以使用接口来对他们抽象出飞行的接口。

package Interface;

public interface MyInterface {// interface是一种数据类型，是引用型

	/*
	 * public MyInterface(){ 接口不能有构造方法，接口不是类 }
	 */
		//private String name=12;只能是公共的  
	
	String name = "张三";
	public static final String NAME = "张三";//与上面代码完全相同
	
	/** JDK1.8新特性 ,接口中可以有非抽象方法*/
	public  default void myMethod() {

		System.out.println("myMethod");
	}
	
	public static void myMethod2() {      //接口中可以有静态方法
		System.out.println("myMethod");
	}
	  void show();

	String fun();

	int[] meythed();// 与下面抽象类的三个方法的作用完全相同，都为public的抽象方法
}

 abstract class MyClass {      //抽象类
	public abstract void show();

	public abstract String fun();

	public abstract int[] meythed();

}

6. 内部类详解

**
(1) 内部类有哪些特点？

1.内部类作为外部类的成员，可以直接访问外部类的成员（包括private成员），反之不行。

2.内部类需要通过外部类来访问。

3.内部类作为外部类的成员，可以声明为private、默认、protected、或者public。

4.内部类成员只有在内部类的范围之内有效。

5.用内部类定义在外部类中不可访问的属性。这样就在外部类中实现类比外部类的private还小的权限。

6.JDK1.8之前方法中的内部类要访问外部类的局部变量，必须加上final关键字。JDK1.8以后，在访问外部类的局部变量时，则可以不加final关键字。

(2) 内部类可以分哪几类？

1.成员内部类（内部类相当于外部类的成员）

package innerClass;

public class Face {     //face类

	private String shape = "瓜子脸";// 脸的属性

	public class Nose {
		private String shape = "高鼻子"; // 鼻子的属性

		public void breath() {
			// 当内部类与外部类具有相同的属性时,在访问外部类的属性时,需要加上类名.this.属性
			System.out.println(Face.this.shape);
			System.out.println("在使用呼吸！");
		}
	}
}

package innerClass;

import innerClass.Face.Nose;

public class TestFace {   //测试类

	public static void main(String[] args) {
		//创建的是脸的对象
		Face f = new Face();
		//创建鼻子的对象
		Nose n = f.new Nose();
		n.breath();
		Nose n1 = new Face().new Nose();
	}
}

2.静态内部类

package innerstatic;

public class Outer {

	//静态内部类，不允许访问外部类的非static属性
	//如果内部类中的方法和属性为static方法,那么内部类也必须为静态的
	 static class Inner{
		static int a = 1;
		static void print() {
			System.out.println("静态内部类！");
		}
	}
}



package innerstatic;

public class TestStaticInner {

	public static void main(String[] args) {
		Outer.Inner i = new Outer.Inner();//创建内部类的对象
		
		Outer.Inner.print();     //访问的是静态内部类中的静态方法
		int a = Outer.Inner.a;
	}
}

3.方法中的内部类

package innermethod;

public class Outer {

	public void show() {//方法内部类
	
		class Inner{    //内部类相当于show方法中的局部变量,使用范围只能在show方法中
			int a = 10;//方法中的局部变量
			public void fun() {
				System.out.println("a="+a);
			}
		}
		
		new Inner().fun();
	}
}

只能在方法中使用，相当于方法中的局部变量

4.匿名内部类（存在继承或者实现关系）

package inneranonymous;

public abstract class Father {   //父类
	abstract public void dream();

}

class Test{
	public static void main(String[] args) {
		
		
		//匿名内部类,没有名字的子类
		Father f2 = new Father() {     //没有名称的子类,通过父类来创建子类对象
			@Override
			public void dream() {    //重写父类的方法
				System.out.println("努力实现父亲的梦想！");
			}
		};
		f2.dream();
	}
}

7. String类常用方法_API文档阅读

(1) String类位于哪个包中，在API中String在的定义是什么？

答：位于java.lang包中。

(2) 请你列举出String类的五个常用方法？

char charAt(int index)返回字符串中第index个字符（下标从0开始）。
boolean，equalsIgnoreCase(String ohter)如果字符串与other相等（忽略大小写），则返回true。
int indexOf(String str) lastIndexOf()查找指定的字符串出现的位置。找到返回索引，找不到返回-1。indexOf()是从前往后查，lastIndexOf()是从后往前查。
int length()返回字符串的长度。

String replace(char oldChar,char newChar ),返回一个新的字符串，这个字符串是将原来的字符串中的oldChar全部替换成newChar的字符串

 package string;
 
 public class TestSteing {
 
 	public static void main(String[] args) {
 		String str = "helloworld";
 		String str2 = "HEllowoRLd";
 		System.out.println(str.charAt(1));//e
 		System.out.println(str.equalsIgnoreCase(str2));//true
 		System.out.println(str.indexOf("o"));//4
 		System.out.println(str.lastIndexOf("o"));//6从后往前
 		System.out.println(str.lastIndexOf("o",3));//-1.      从后往前,从下标为3的位置开始数
 		System.out.println(str.length()); // 10,     字符串字符的长度
 	System.out.println(str.replace("o", "a"));//hellawarld    将o全部替换成a
 }

}