面向对象（下）

最新推荐文章于 2022-05-13 15:53:36 发布

大盼

最新推荐文章于 2022-05-13 15:53:36 发布

阅读量568

点赞数

分类专栏： Java 文章标签： java 多态继承 jar interface

本文链接：https://blog.csdn.net/a254830856/article/details/23271299

版权

Java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

知识点汇总

1.继承

1.1 继承的概念：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。

示例：class SubDemo extends Demo{}

继承的作用：
继承的出现提高了代码的复用性。

继承的出现让类与类之间产生了关系，提供了多态的前提。

1.2 继承的特点：

Java只支持单继承，不支持多继承。

一个类只能有一个父类，不可以有多个父类。

class SubDemo extends Demo{}

Java支持多层继承(继承体系)

class A{}

class B extends A{}

class C extends B{}

定义继承需要注意：
不要仅为了获取其他类中某个功能而去继承
类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

代码示例：

class Person
{
	String name;
	int age;
}
class Student extends Person
{	
	{//构造代码块;此语句中的name和age继承父类得来
		System.out.println("name:"+name+"...age:"+age);
	}
	public static void info(String name, int age)
	{
		System.out.println("name:"+name+"...age:"+age);
	}
}
class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.info("lisi",21);
	}
}

1.3 super关键字

super和this的用法相像

this代表本类对象的引用

super代表父类的内存空间的标识。也就是父类对象的引用

当子父类出现同名成员时，可以用super进行区分

子类要调用父类构造函数时，可以使用super语句。

代码示例：

/**
super关键字
super代表父类对象的引用
super用于构造函数间的调用
*/
class Person
{
	String name;
	int age;
	Person(String name,int age)
	{
	this.name = name;
	this.age = age;
	}
}
class Student extends Person
{
	Student(String name,int age)
	{
		super(name,age);//通过super调用父类中构造器的初始化
	}
}
class Teacher extends Person
{
	double height;
	Teacher(String name,int age,double height)
	{
	super(name,age);
	this.height = height;
	}
}
class SuperKeyWord
{
	public static void main(String[] args) 
	{
		Student s = new Student("lisi",22);
		Teacher t = new Teacher("zhangsan",98,171.1);
		System.out.println("name:"+t.name+"...age:"+t.age+"...height:"+t.height);
	}
}

1.4 函数覆盖

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

1.5 函数覆盖的注意事项

父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
覆盖时，子类方法权限一定要大于等于父类方法权限
静态只能覆盖静态。

1.6 子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数，因为每个构造函数的第一行都有一条默认语句super（）；

先执行父类中没有被子类覆盖的方法，然后执行子类中覆盖父类的新方法。

代码示例：

/**
覆盖
需求：写一个表现覆盖特性的程序
分析：
首先要定义一组子父类
子类复写父类中的方法
思路：
父类：Person;子类：student
子类方法：run(){“zi run”}父类方法run(){"fu run"}
*/
class Person
{
	void run()//Person类中的run方法
	{
		System.out.println("Person run");
	}
}
class Student extends Person
{
	void run()//Student类中的run方法
	{
		System.out.println("Student run");
	}
}
class OverWriteDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.run();//此时输出的是student中的run方法
	}
}

1.7 final关键字

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量。只能被赋值一次。

内部类只能访问被final修饰的局部变量。

1.8 抽象类

定义：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

1.9 抽象方法

多个对象都具备相同的功能，但是功能的具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

抽象方法的格式：

修饰符 abstract 返回值类型函数名(参数列表) ;

1.10 抽象类的特点：

抽象类不可以实例化，通过子类来创建对象（这个在后面中经常用到）

抽象类和抽象方法必须用abstract关键字修饰

抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

代码示例：

/**
抽象类和抽象方法
需求：写一个演示抽象类和抽象方法特点的程序
分析：
写一组子父类
父类中有抽象方法，父类是抽象类
子类覆盖父类中的抽象方法
思路：
父类：Person；子类：student，teacher
抽象方法：abstract work（）；
在子类中定义work（）覆盖
*/
abstract class Person//抽象类
{
	abstract void work();//抽象方法
}
class Student extends Person
{
	void work()//复写父类中的work抽象方法
	{
		System.out.println("study");
	}
}
class Teacher extends Person
{
	void work()
	{
		System.out.println("teach");
	}
}
class AbstractDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.work();
		Teacher t = new Teacher();
		t.work();
	}
}

1.11 接口

接口的格式：interface{}

接口中的成员修饰符是固定的。

成员常量：public static final

成员函数：public abstract

发现接口中的成员都是public的。

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

1.12 接口的特点

接口是对外暴露的规则。

接口是程序的功能扩展。

接口的出现降低耦合性。

接口可以用来多实现。

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

代码示例：

interface A
{
	public static final int a = 1;
	public abstract void getA();
} 
interface B
{
	public static final int b = 2;
	public abstract void getB();
}
interface C extends A,B//接口支持多继承
{
	public static final int c =3;
	public abstract void getC();
}
class  InterfaceDemo
{
	public static void main(String[] args) 
	{
		System.out.println(C.a);
		System.out.println(C.b);
		System.out.println(C.c);
	}
}

1.13 接口与抽象类

共性：

接口与抽象类都是抽象出来的概念

区别：

抽象类体现继承关系，一个类只能单继承

接口体现实现关系，一个类可以多实现

抽象类是继承，是 "is a "关系

接口是实现，是 "like a"关系

抽象类中可以定义非抽象方法，供子类直接使用

接口的方法都是抽象，接口中的成员都有固定修饰符

2.多态

2.1 定义：某一类事物的多种存在形态。

程序中体现：

父类或者接口的引用指向或者接收自己的子类对象。

好处：

多态的存在提高了程序的扩展性和后期可维护性

弊端：

只能使用父类的引用访问父类中的成员。

前提：

需要存在继承或者实现关系

要有覆盖操作

引用类型提升：

父类引用指向子类对象，这种情况就是类型提升，向上转型

父类引用指向子类对象时，该引用可以被提升，也可以被向下转型。

2.2 多态的特点

成员函数：编译时，看左边，运行时，看右边。

编译时：要查看引用变量所属的类中是否有所调用的成员。

在运行时：要查看对象所属的类中是否有所调用的成员。

成员变量：只看左边

只看引用变量所属的类。

代码示例：

/**
多态演示
分析：
定义动物类 猫类 狗类
动物类中定义吃东西的抽象方法
猫类中定义猫吃东西的方法和抓老鼠的方法
狗类中定义狗吃东西的方法和看家的方法
猫类和狗类继承动物类
分别调用猫和狗吃东西的方法
调用猫抓老鼠的方法
调用狗看家的方法
*/
abstract class Animal
{
	public abstract void eat();
}
class Cat extends Animal
{
	public void eat()
	{
		System.out.println("吃鱼");
	}
	public void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}
class Dog extends Animal
{
	public void eat()
	{
		System.out.println("吃骨头");
	}
	public void kanJia()
	{
		System.out.println("看家");
	}
}
class  DuoTaiDemo
{
	public static void main(String[] args) 
	{
		function(new Cat());//匿名对象作为参数进行传递
		function(new Dog());
	}
	public static void function(Animal a)//引用类型的提升
	{
		a.eat();
		if (a instanceof Cat)//判断Cat类是否包含在Animal类中
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}else
			if (a instanceof Dog)
			{
				Dog d = (Dog)a;
				d.kanJia();
			}
	}
}

2.3内部类

定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。

为什么内部类可以直接访问外部类中的成员呢？
那是因为内部中都持有一个外部类的引用。这个引用是外部类名.this.

内部类的特点：

内部类定义在成员位置上

可以被private static成员修饰符修饰。

被static修饰的内部类只能访问外部类中的静态成员。

内部类定义在局部位置上

可以直接访问外部类中的成员。

同时可以访问所在局部中的局部变量，但必须是被final修饰的。

外部类访问内部类方式：

1，当内部类定义在外部类成员位置上，而且非私有。在外部类其他类中，可以直接建立内部类对象。

格式：

外部类名.内部类名变量名 = 外部对象.内部对象；

Outer.Inner in = new Ouert().new Inner();//这种方法很少用

2，当内部类出现在成员位置上就可以被成员修饰符所修饰

例如：private：将内部类在外部类中进行封装；

static：内部类就具备static的特性

当内部类被static修饰后，只能直接访问外部类中的static成员，访问受到了限制

在外部其他类中，如何直接访问static内部类的非静态成员的呢？

new Outer.Inner().function();

如何直接访问staitc内部类的静态成员呢？

Outer.Inner.funtion();

当外部类中的静态方法访问内部类时，内部类必须是静态的

当内部类中定义了静态成员，该内部类必须是静态的

代码示例：

/**
内部类
*/
class Outer
{
	int num = 0;
	class Inner
	{
		void show()
		{
			System.out.println("num:"+num);//内部类可以访问外部类中的成员，包括私有成员
		}
	}
	public void method()
	{
		Inner i = new Inner();//外部类要访问内部类要建立内部类的对象
		i.show();
	}
}
class InnerClass 
{
	public static void main(String[] args) 
	{
		Outer ou = new Outer();
		ou.method();
	}
}

2.4 匿名内部类

匿名内部类就是内部类的简化写法。
前提：
内部类可以继承或实现一个外部类或者接口。

格式为：
new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。

代码示例：

/**
匿名内部类
*/
abstract class A
{
	abstract void show();
}
class Outer
{
	int num = 3;
	public void function()
	{
		//匿名子类对象
		new A()
		{
			void show()//匿名内部类中的方法
			{
				System.out.println("num="+num);
			}
		}.show();
	}
}
class NoNameClass
{
	public static void main(String[] args) 
	{
		Outer ou = new Outer();
		ou.function();
	}
}

Object类中的equals()方法和toString()方法

equals()：用于比较两个对象是否相等，实际上是比较两个对象的引用类型变量中存储的地址值是否相等

根据对象的属性不同，判断对象是否相同的具体内容也不一样。所以在定义类时，一般都会复写equals方法。

toString()：Object类提供的toString方法总是返回该对象实现类的“类名+@+hashCode”值，这个返回值并不能真正实现“自我描述”的功能，因此如果用户需要自定义类能实现“自我描述”的功能，就必须重写Object类的toString方法。

equals()和“==”的区别

equals()：是方法，用来比较对象的内存地址值，是引用型变量间的比较

== ：是运算符，可用于基本数据类型间比较，比较的是数值

也可用于引用数据类型的比较，比较的是内存地址值

代码示例：

class Students//单例设计模式，定义一个类
{
	private int age;
	private Students(){};
	private static Students s = new Students();
	public static Students show()
	{
		return s;
	}
}
class EqualsDemo 
{
	public static void main(String[] args) 
	{
		//分别建立对象s1,s2
		Students s1 = Students.show();
		Students s2 = Students.show();
		boolean a = s1.equals(s2);//判断两个对象是否相等
		System.out.println(a);//返回值是true
	}
}

toString()：Object类提供的toString方法总是返回该对象实现类的“类名+@+hashCode”值，这个返回值并不能真正实现“自我描述”的功能，因此如果用户需要自定义类能实现“自我描述”的功能，就必须重写Object类的toString方法。

代码示例：

/**
toString
思路：
定义一个类Student
显示初始化name和age变量
修改类中的name
输出修改后的对象
*/
class Student
{
	String name;
	int age;
	Student(String name,int age)
	{
		System.out.println("name:"+name+"...age:"+age);
	}
	public String toString()
	{
		return "name:"+name+"...age:"+age;
	}
}
class ToStringDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student("zhangsan",22);
		s.name = "lisi";
		System.out.println(s.toString());
	}
}

3. 包(package)

3.1 包的概述

对类文件进行分类管理。

给类提供多层命名空间。

写在程序文件的第一行。

类名的全称的是包名.类名。

包也是一种封装形式。

3.2 包之间的访问

被访问的包中的类权限必须是public的。

类中的成员权限：public或者protected

protected是为其他包中的子类提供的一种权限

3.3 四种权限

3.4 import

简化类名。

一个程序文件中只有一个package，可以有多个import。

用来导包中的类，不导入包中的包。

3.5 jar包

jar包的概述：

Java的压缩包

方便项目的携带。

方便于使用，只要在classpath设置jar路径即可。

3.6 jar包的操作

通过jar.exe工具对jar的操作。

创建jar包

jar -cvf mypack.jar packa packb

查看jar包

jar -tvf mypack.jar [>定向文件]

解压缩

jar -xvf mypack.jar

自定义jar包的清单文件

jar –cvfm mypack.jar mf.txt packa packb

大盼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象（下）

知识点汇总1.继承1.1 继承的概念：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。子类可以直接访问父类中的非私有的属性和行为。通过 extends 关键字让类与类之间产生继承关系。示例：class SubDemo extends Demo{
复制链接

扫一扫

专栏目录