Java基础四-面向对象三大特征，抽象类，接口与内部类

最新推荐文章于 2021-10-24 08:15:50 发布

林华觞

最新推荐文章于 2021-10-24 08:15:50 发布

阅读量300

点赞数

分类专栏： Java基础文章标签： java 抽象类多态封装

本文链接：https://blog.csdn.net/weixin_44359369/article/details/118686191

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

面向对象的三大特征是：继承，封装和多态。

1.继承

继承使类的扩展更加容易，实现了代码的重用，编程中使用extends实现继承。
要点：
1.父类也被称为超类，基类派生类等
2.java类中没有多继承，接口有多继承
3.子类继承父类，可以得到父类全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如父类的私有属性和方法）
4.如果一个类定义使，没有调用extends，则它的父类是java.lang.Object
instanceof:
instanceof是二元运算符，左边是对象右边是类；当对象时右边类的或子类所创建对象时返回值为true；否则，为false；

class Student{
		int age;
		String name;
}
public class Test{
		public static void main(String[]args){
				Student s=new Student();
				System.out.println(s instanceof Student );//结果为true
		}
}

子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写要满足以下三个要点：
1.==：方法名，形参列表相同
2<=：返回值类型和声明异常类型子类小于等于父类
3.>=：访问权限，子类大于等于父类。
Object：
Object类是所有类的基类，也就意味着所有的java对象都拥有Object类的属性和方法。
toString方法：
源码：

public String toString(){
		return getClass().getName()+"@"+Interger.toHexString(hashCode());
}

重写：

class Person{
		int age;
		String name;
		public String toString(){
			return name+",年龄："+age;
		}
}

==与equals
“==”代表比较双方是否相同。如果是基本数据类型则表示值相等，如果是引用类型则表示地址相等，即指向同一个对象。
Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑
重写：

class Person{
		int id;
		String name;
		public Person(int id,String name){
			this.id=id;
			this.name=name;
		}
		public boolean equals(Object obj){
			if(obj==null){
			  return false;
			  }else{
			  			if(obj instanceof Person){
			  					Person c=(Person)obj;
			  					if(c.id==this.id){
			  					return true;
			  					}
			  			}
			  }
			  return false;
		}
}

JDK提供的一些类，比如String,Date,包装类等，重写了Object类的equals方法，调用这些类的equals方法，x.equals(y)，当x和y所引用的对象是同一类对象且属性内容相等（并不一定是同一对象），返回true；否则返回false；
super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

public class Test{
		public static void main(String[]args){
		new ChildClass().f();
		}
}

class FatherClass{
		public int value;
		public void f(){
			value=100;
			System.out.println("FatherClass.value="+value);
		}
}

class ChildClass extends FatherClass{
		public int value;
		public void f(){
				super.f();//调用父类对象的普通方法
				valie=200;
				System.out.println("ChildClass.value="+value);
				System.out.println(value);
				System.out.println(super.value);//父类对象的成员变量
		}
}

继承树追溯
属性/方法查找顺序（比如查找变量h）：
1.查找当前类中有没有属性h
2.依次上溯每个父类，查看父类中是否有h，直到Object
3.如果没有找到，则出现编译错误
4.上述步骤，只要找到h，过程立即终止
构造方法调用顺序：
构造方法第一句总是supeu（）来调用父类对应的构造方法。所以顺序是：先向上追溯到Object类，在依次向下执行类的初始化块和构造方法，直到当前子类为止。

2.封装

封装的优点：
1.提高代码的安全性
2.提高代码的复用性
3.“高内聚”：封装细节，便于修改内部代码，提高可维护性
4.“低耦合”：简化外部调用，便于调用者使用，便于扩展和协作
封装的实现----使用访问修饰符
四种访问修饰符：public private protected default；
访问权限见下表：

修饰符	同一个类	同一个包	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

说明：
1.private表示私有，只有自己类能够访问
2.default表示没有修饰符修饰，只有同一个包的类能访问
3.protected表示可以被同一个包的类以及其他包中的子类访问
4.public表示可以被该项目中的所有类访问
setter与getter方法快捷（eclipse）：右键—>Source—>Generate Getters and Setters---->选择对应的属性即可。
JavaBean的封装实例：

package 第四章;

public class Person {
	//属性一般用private修饰
     private int age;
	 private String nameString;
     private boolean flag;
     public int getAge() {
 		return age;
 	}
 	public void setAge(int age) {
 		this.age = age;
 	}
 	public String getNameString() {
 		return nameString;
 	}
 	public void setNameString(String nameString) {
 		this.nameString = nameString;
 	}
 	//对于布尔类型变量不是getFlag而是isFlag
 	public boolean isFlag() {
 		return flag;
 	}
 	public void setFlag(boolean flag) {
 		this.flag = flag;
 	}
}

3.多态（polymorphism）

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。
多态的要点：
1.多态是方法的多态，不是属性的多态（多态与属性无关）
2.多态存在的3个必要条件：继承，方法重写，父类引用指向子类对象
3.父类引用指向子类对象后，用该父类对象引用调用子类重写的方法，此时多态出现了。

package 第四章;

public class Test {
public static void main(String[] args) {
	Cat cat=new Cat();
	animalShout(cat);
 }
static void animalShout(Animal animal) {
	animal.shout();
}
	
}
class Animal{
 public void shout() {
	 System.out.println("叫了一声。");
 }
}
class Cat extends Animal{
	public void shout() {
		System.out.println("喵喵。");
	}
}
class Dog extends Animal{
	public void shout() {
		System.out.println("汪汪。");
	}
}

虽然是Cat cat=new Cat（）；但animalShout方法形参是Animal类型的，也算父类引用执行子类对象。显然，animalShout方法的实参可以是cat，dog等Animal类的子类对象，从而大量重载方法。

4.对象的转型

父类引用子类对象，我们称这个过程为向上转型，属于自动类型转换
向上转型后的父类引用变量只能调用它编译类的方法，不能调用它运行时类的方法。此时需要进行类型的强制转换，我们称之为向下转型。

5.final关键字

作用：
1.修饰变量：被修饰的变量不可更改，一旦赋值，就不能被重新赋值
2.修饰方法：该方法不可被子类重写，但是可以被重载
3.修饰类：修饰的类不能被继承：比如Mash，String等。

6.抽象方法和抽象类

抽象方法：
使用abstract修饰的方法，没有方法体，只有声明。定义的是一种规范，就是告诉子类必须实现要给抽象方法提供具体的实现
抽象类：
包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用

package AbstractAndInterface;

public class AbstractTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog dog = new Dog();
		dog.shout();
		dog.seeDoor();

	}

}

//抽象类
abstract class Animal {
	abstract public void shout();// 抽象方法
}

class Dog extends Animal {

	@Override
	public void shout() {
		// TODO Auto-generated method stub
		System.out.println("狗汪汪叫。");
	}

	public void seeDoor() {
		System.out.println("狗子看门中。");

	}

}

使用要点：
1.有抽象方法的类只能定义成抽象类
2.抽象类只能用来被继承，不能实例化，即不能通过new来实例化抽象类
3.抽象类可以包含属性，方法，构造方法。但是构造方法不能用来new实例，只能用来被子类调用
4.抽象方法必须被子类实现。

7.接口

接口是比“抽象类”还抽象的“抽象类”：抽象类还提供了某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法，接口是完全面向规范的。从接口的实现者角度看：接口定义了可以向外部提供的服务；从接口的调用者角度看：接口定义了实现者能提供哪些服务。
区别：
普通类：具体实现
抽象类：具体实现，规范（抽象方法）
接口：规范
声明：
[访问修饰符]interface 接口名[extends 父接口1，父接口2…]{
常量定义；方法定义；
}
说明：
1.访问修饰符：只能是public或默认
2.接口名命名规则与类名相同
3.extends：接口可以多继承
4.常量：接口中的属性只能是常量，总是public static final修饰，不写也是
5.方法：接口中的方法只能是public static，省略的话也是public static
要点：
1.子类通过implements来实现接口中的规范
2.接口不能创建实例，但可用于声明引用变量类型
3.一个类实现了接口，必须实现接口中的所有方法，并且这些方法只能是public的
4.JDK1.7之前，接口中只能包含静态常量，抽象方法，不能具有普通属性，构造方法，普通方法；JDK1.8之后，接口中可包含普通的静态方法
5.接口支持多继承。子接口会获得父接口所定义的一切。

8.面向接口编程

面向接口编程是面向对象编程的一部分。接口是规范，是项目中最稳定的东西。通过面向接口编程，可以大大降低程序模块间的耦合性，提高整个系统的可扩展性和可维护性。

9.内部类

分类：
成员内部类（非静态内部类，静态内部类），匿名内部类，局部内部类。
成员内部类：
可以使用private，default，protected，public任意进行修饰。类文件：外部类$内部类.class
非静态内部类
外部类里使用非静态内部类与平时使用其他类没什么区别
1.非静态内部类必须寄存在一个类对象里。因此，如果有一个非静态内部类的对象那么一定有一个对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
2.非静态内部类可以直接访问外部类的成员，但外部类不能直接访问内部类的成员
3.非静态内部类不能有静态方法，静态属性和静态初始化块
4.外部类的静态方法，静态代码块不能访问非内部静态类，包括不能使用非静态内部类定义变量，创建实例
5.成员变量访问要点：
（1）内部类里方法的局部变量：变量名
（2）内部类属性：this.变量名
（3）外部类属性：外部类名.this.变量

package InerClass;

public class UnStaticInerClass {
public static void main(String[] args) {
	Outer.Inner inner=new Outer().new Inner();
	inner.show();
}
}
class Outer{
	private int age=10;
	class Inner{
		int age=20;
		public void show() {
			int age=30;
			System.out.println("内部类方法里的局部变量age="+age);//30
			System.out.println("内部类成员变量age="+this.age);//20
			System.out.println("外部类的成员变量age="+Outer.this.age);//10
			
		}
	}
}

静态内部类：
定义方式：
static class className{类体}
使用要点：
1.当一个静态内部类对象存在，并不一定存在一个对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。
2.静态内部类看做外部类的一个静态成员。因此，外部类的方法可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过new静态内部类（）访问静态内部类的实例。

class Outer{
static class Inner{
	
}
}
public class Test{
	public static void main(String[] args) {
		
		Outer.Inner inner=new Outer.Inner();
	}
}
}

匿名内部类
适合于那种只需要使用一次的类。比如：键盘监听操作等。（常用与移动应用开发）
语法：
new 父类构造器（实参列表）\实现接口{匿名内部类体}
代码实例：

package InerClass;

import java.awt.event.KeyEvent;
import java.awt.event.WindowEvent;

public class Inner {
	this.addWindowListener(new WindowAdapter() {
		@Override
		public void windowClosing(WindowEvent e) {
			System.exit(e);
		}
	});
	
	this.addKeyListener(new KeyAdapter() {
		@Override
		public void keyPressed(KeyEvent e) {
			myTank.KeyPressed(e);
		}
		@Override
		public void keyReleased(KeyEvent e) {
		myTank.KeyReleased(e);
		}
	});

}

注意：
1.匿名内部类没有访问修饰符
2.匿名内部类没有构造方法。因为它连名字都没有哪来的构造方法呢
局部内部类
定义在方法内部，作用域仅限于本方法，称为局部内部类。实际开发中引用很少

package InerClass;

public class Test{
	public void show() {
		//作用域仅限于该方法
		class Inner{
			public void fun() {
				System.out.println("Heloo world.");
			}
		}
		new Inner().fun();
	}
	public static void main(String[] args) {
		new Test().show();
	}
}

林华觞

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础四-面向对象三大特征，抽象类，接口与内部类

面向对象的三大特征是：继承，封装和多态。1.继承继承使类的扩展更加容易，实现了代码的重用，编程中使用extends实现继承。要点：1.父类也被称为超类，基类派生类等2.java类中没有多继承，接口有多继承3.子类继承父类，可以得到父类全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如父类的私有属性和方法）4.如果一个类定义使，没有调用extends，则它的父类是java.lang.Objectinstanceof:instanceof是二元运算符，左边是对象右边是类；当对象时
复制链接

扫一扫