包_权限修饰符_多态_抽象

最新推荐文章于 2024-11-05 19:36:08 发布

Levana_123

最新推荐文章于 2024-11-05 19:36:08 发布

阅读量122

点赞数

分类专栏： javaSE 文章标签：多态抽象类 java

本文链接：https://blog.csdn.net/qq_41541451/article/details/110946026

版权

javaSE 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

包

含义：将类文件放到文件夹中

作用：1、可以通过不同的作用将类文件分类，放到不同的包下。便于我们的使用和搜索；2、就可以在不同的包下定义相同的类名。

包的生成：javac是对java源文件的编译，java 运行

包的声明：

格式：package 包名

命名规范：字母全部小写，倒序

注意事项：1、必须将package声明放在代码的第一行；2、一个源文件中只能有一个package语句

包名的要求要做到全球唯一：www.sdlg.com com.(域名.全球).sdlg.java1207.ls.demos

带包声明类的编译：

效果：编译完成之后会自动创建文件夹，并且将类文件直接放入包中

编译完成之后类名会发生变化

包名+类名才是现在的全类名

带包的字节码文件需要到包所在的路径下才能够正常运行

导包：

如果不导包就需要用到全类名，比较麻烦，所以就使用全类名的简写形式

import 包名我们在之后使用类时直接可以省略包名

注意事项：

1、不要导入import * （加载时间久

2、遇到相同的类名在不同的包下，此时这种情况必须要使用全类名

权限修饰符

含义：就是一些关键字，用于修饰成员，表示成员可以在那些范围内被访问

罗列：

Private 私有的；可以再本类中访问

默认的；可以在本类中访问，可以被本包中的子类继承和访问，可以在本包中的无关类被访问

protected 保护的；可以在本类中访问，可以被本包中的子类继承和访问，可以在本包中的无关类被访问，可以再其他包中的子类被继承

public 公开的；可以在本类中访问，可以被本包中的子类继承和访问，可以在本包中的无关类被访问，可以再其他包中的子类被继承和访问，可以再其他包中的无关类被访问

（1）四个权限都能在本类中被访问

public class Person {
//四个权限都能在本类中访问
	private int age = 10;
	String name = "张三";
	protected int price = 100;
	public double sarlay = 1000.0;
	public static void main(String[] args) {
		Person p = new Person();
		System.out.println(p.age);//private 修饰的成员可以在本类中访问
		System.out.println(p.name);//默认的权限 修饰的成员可以在本类中访问
		System.out.println(p.sarlay);//被保护的权限修饰符 修饰的成员可以在本类中访问
		System.out.println(p.price);//公开的成员 可以在本类中访问
	}
}

（2）本包的子类，除了private，其他三个权限都可在本包的子类中被继承和访问

package x;
//本包的子类
public class Test extends Person{
	public void test() {
		//System.out.println(age);//被私有化的成员无法被子类继承
		System.out.println(name);//默认权限修饰的成员可以被子类继承
		System.out.println(price);//被保护的成员可以被子类继承
		System.out.println(sarlay);//public的成员可以被子类继承
	}

	public static void main(String[] args) {
		Person p = new Person();
		//System.out.println(p.age);//被私有化的成员无法再子类中访问
		System.out.println(p.name);
		System.out.println(p.price);
		System.out.println(p.sarlay);
		
	}
}

（3）本包的其他类，除了private，其他三个权限都可在本包的其他类中被访问

package x;

public class Test1 {

	public static void main(String[] args) {
		Person p = new Person();
		//System.out.println(p.age);
		System.out.println(p.name);
		System.out.println(p.price);
		System.out.println(p.sarlay);
	}
}

（4）其他包的子类：protected和public可以被其他包的子类继承，只有public可以被访问

package y;
//其他包中的子类
import x.Person;

public class Test1 extends Person{

	public void test() {
		//System.out.println(age);
		//System.out.println(name);
		System.out.println(price);
		System.out.println(sarlay);
	}
	public static void main(String[] args) {
		Person p = new Person();//创建父类的对象，访问父类的资源
		System.out.println();
		//System.out.println(age);
		//System.out.println(p.name);
		//System.out.println(p.price);
		System.out.println(p.sarlay);
	}
}

（5）其他包的其他类：只有public可以被访问

多态

概述

含义：事物的多种形态

一个名称可以指向多个不同的事物：一个引用可以指向不同类型的对象，，，动物->猫or狗

不同的事物可以有相同的称谓：一个对象可以被多个引用所指向，，，狗->动物or可爱的生灵

发生多态的前提：1、继承；2、方法的重写；3、父类的引用指向了子类的对象

多态的成员变量的访问特点

编译看左边，运行看左边

在编译阶段直接去父类寻找有没有这样的变量，如果有编译成功，如果没有编译报错。

运行阶段还是直接去访问父类中的成员的值，如果没有赋值直接输出默认值

多态的成员方法的访问特点

编译看左边，运行看右边

在编译阶段直接去父类寻找有没有这样的成员方法，如果有编译成功，如果没有编译报错。

运行阶段再父类中查看到当前的成员，然后去子类中寻找重写过的成员，运行的是子类中重写的成员

多态的静态成员访问特点

编译看左边，运行看左边

编译阶段就是在父类中寻找当前的静态成员

运行阶段也是执行父类中的静态成员

静态的总结：

静态的变量，被static修饰的成员，是相对于当前的类型（对象）是静止的（优于对象先去加载

成员方法：被static修饰的成员方法，是相对于子类静态的，不管子类如何变化，静态的成员变量都不会变

总结：静态与多态无关

超人案例：

public class Demo05_超人案例 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Man1 m = new SuperMan();
		System.out.println(m.name);//成员变量看左边
		m.dealBusness();//成员方法看右边
		//m.fly();不可以，自动向上转型，只能实现父类的功能
		SuperMan sm = (SuperMan)m;//向下转型
		sm.fly();		
	}
}
class Man1{
	String name = "Mike";
	public void dealBusness() {
		System.out.println("谈普通生意");
	}
}
class SuperMan extends Man1{
	String name = "蜘蛛侠";
	@Override
	public void dealBusness() {
		System.out.println("谈几个亿的大单子");
	}
	public void fly() {
		System.out.println("放飞自我，自由飞翔，救人");
	}
}

向上和向下转型

向上转型：父类的引用指向子类的对象，就是向上转型

本质：就是将小的对象的引用提升为大的对象，只能访问父类中有的成员，将子类的访问范围缩小

向下转型：将子类的引用恢复

格式：子类类型对象名 = （子类类型）对象名；

本质上就是将父类引用指向的对象恢复到子类引用，扩大访问范围。

内存分析：主类先去加载到方法区，静态的main方法也要加载进方法区，一加载进方法区就要进栈了，man引用，方法区加载man，superman进入方法区，有一个引用，栈内存就要开辟一个空间

说明：1、父类的引用指的就是superde引用，范围只能访问父类的范围；2、当成原方法被调用时，父类的引用先去找到父类字节码信息中的方法，返回在返回子类大的空间中找到子类的引用，通过引用找到子类字节码信息，然后获取重写过后的方法去执行，我们称这个过程为动态绑定；3、不需要考虑动态绑定的过程，只需要知道动态绑定的好处，也就是多态的好处

多态的好处

1、可以在形参中用父类的引用指向子类的对象形成多态，不需要再去创建子类对象，直接用父类的引用调用子类中重写过后的方法，就可以完成需求；2、往往在开发中子类是什么样的类型都是不确定的，也不会用new的方式来创建对象，这个对象的来源非常广泛；文件、配置、网络中。。。然后通过反射的机制来创建对象。这种方式就不需要我们去确定子类，只需要在对象源中修改配置信息即可；3、多态大大的提高了代码的可维护性和扩展性。