JavaSE.20190430.权限修饰符.重写.super.final.object.转型.抽象类.面向对象的三大特征之一多态.

咚痞子

于 2019-05-01 22:56:36 发布

阅读量126

点赞数

分类专栏： JavaSE阶段

本文链接：https://blog.csdn.net/LiangEdward/article/details/89714769

版权

JavaSE阶段专栏收录该内容

20 篇文章 0 订阅

订阅专栏

一.权限修饰符

1.权限修饰符

		本类	同包类	不同包子类	不同包其他类
私有的	private	✔
默认的	default	✔	✔
受保护的	protected	✔	✔	✔
公共的	public	✔	✔	✔	✔

注意:
   1)以上四个权限修饰符都是成员修饰符(成员变量,成员方法),不能修饰局部;
   2)被private修饰的内容不能被继承
   3)public和default(不能显示定义)能够修饰类====>default(不能显示定义),因为不写,默认就是default
   4)设计面向对象的原则之一: 开闭原则(对修改关闭,对扩展开放)

二.重写

1.重写 : -->方法
1)不同的类
2)继承
3)方法签名相同

重载 : -->方法
1)同一个类中
   2)多个方法的方法名相同
   3)方法签名不同
2.子类中一旦方法重写,会对父类中同名的进行屏蔽
3.如果子类有重写父类中的方法,调用时会调用子类中重写的方法
4.检测重写方法的方式:
   1)左边有向上的三角
   2)在重写方法的上面添加一个注解 @Override
5.重写满足|注意的条件:
   == 方法签名相同
   <= 返回值类型:基本数据类型:子父类必须相同       引用数据类型:子类<=父类
   >= 权限修饰符:子类>=父类
6.注意:
   1)被private修饰的方法不能被重写
   2)被final修饰的方法不能被重写
3)被static修饰的方法不能被重写
4)如果子类中存在于父类静态方法重名的方法,记住要把子类中这个方法定义为静态的

三.super

1. super:指代父类对象
this: 指代当前创建对象
1) 用在构造器的首行可以调用父类中的构造器
uper(参数)-->匹配父类中构造器的参数
如果没有显示定义,默认在子类构造器的首行存在super(),默认调用父类的空构造
2) 区分子父类同名问题
如果存在同名问题,默认隐藏this,默认就近原则找当前子类中的,如果想要指定父类中,要使用super调用
注意:
先父类后子类
不能显示同时定义this()和super(),因为都要存在于构造器的首行,但是可以隐式同时使用,默认调用父类空构造,显示调用子类其他构造器
就近找局部,然后如果同时存在局部,子类成员,父类成员同名问题,默认找局部,子类成员this,父类成员super

public class SuperDemo {
	public static void main(String[] args) {
		Zi zi =new Zi();
		System.out.println(zi.name);
		zi.test();
	}
}
class Zi extends Fu{
	String name="李四";
	public Zi() {
		super(5);
		//this("哈哈");
		System.out.println("我是子类呵呵呵  微笑");
	}
	public Zi(String str) {
		System.out.println("我是子类带参构造");
	}
	public Zi(int a,int b,int c) {
		super(a,b,c);
		System.out.println("我是zi 类三个参数的构造器哈哈哈");
	}
	void test(){
		String name="王五";
		System.out.println(this.name);  //如果子父类有同名问题,默认调用子类,因为就近原则
		System.out.println(super.name);  //如果子父类有同名问题,默认调用子类,因为就近原则
		System.out.println(name);
		super.haha();
		final int A=5;
		//A=10;
	}
	@Override
	void haha(){
		System.out.println("我是字类中的哈哈");
	}
}
class Fu{
	String name="张三";
	int a;
	int b;
	int c;
	public Fu() {
		System.out.println("我是父类哈哈哈");
	}
	public Fu(int a,int b,int c) {
		this.a=a;
		this.b=b;
		this.c=c;
		System.out.println("我是父类三个参数的构造器哈哈哈");
	}
	public Fu(int a) {
		System.out.println("我是父类带参构造");
	}
	void haha(){
		System.out.println("我是父类中的哈哈");
	}
}

四.final 最终的
   被final修饰的变量为常量,不能改变
   被final修饰的方法,不能被重写
   被final修饰的类不能被继承(太监类)
final Person p=new Person();
p.name="张三";

五.object 所有类的父类(老祖宗类)

1.在java中的所有类都会直接或者间接的继承自Object
2.toString: 打印一个对象的引用,默认调用这个对象的toString()方法
目的: 打印对象的信息的字符串表示形式
类中重写toString方法,自定义方法体的实现
== 比较的是地址
equals : 可以比较对象的内容是否相同
public boolean equals(Object obj) {
return (this == obj);
}
equals在Object中默认比较的还是对象的地址

六.面向对象的三大特征之一多态
1.一种事物多种形态|多种表现形式
2.多态的前提:
类的继承 | 接口的实现
3.多态的最终体现:
父类的引用指向子类的对象
4.多态的目的:
父类的引用在调用子父类中同名方法的时候,会调用子类中重写的方法
注意:子类中新增的方法对父类不可见

5. 多态使用成员
成员变量:
编译运行找父类
编译运行看左边
   成员方法:
   编译看父类,运行看子类
   编译看左边,运行找右边
   编译看类型,运行找对象

6.面向对象:
   思想:
   封装:对外隐藏内部的实现细节,提供公共的访问方式
   继承:子类继承父类,就可以拥有父类中的成员
   多态:在继承的前提下和方法重写的前提下,可以提高代码的服用型和扩展性

public class PolymorphicDemo01 {
	public static void main(String[] args) {
		//本类的引用指向本类的对象,当前类中所有内容都可以使用(父类继承的+自己新增的)
		Student s=new Student();
		s.name="马云";
		s.eat();
		s.subject="java";
		s.study();
        //	Person p=new Person();
		//多态
		Person s1=new Student();
		s1.name="李彦宏";
		s1.eat();
		//s1.study();  //父类的引用对子类新增的方法不可见
	}
}
class Person{
	String name;
	void eat(){
		System.out.println("每天吃饭8小时,幸福感只比敲代码少一点点...");
	}
}
class Student extends Person{
	String subject;	
	void study(){
		System.out.println("每天学习java不止12小时,做梦都在敲代码...");
	}	
	void eat(){
		System.out.println("边吃饭边敲代码,边睡觉变敲代码");
	}
}

七.转型
   1.孔子装爹:
   孔子{name=孔子;age=18; void teach(){讲论语...} void play(){打王者}}
   孔子{name=孔子爹;age=30; void teach(){做生意...}}
   有一个人来找孔子爹讲做生意上课,但是孔子爹去旅行
   办法: 孔子化妆装成他爹的样子去上课 --向上转型
   KongZiDie k=new KongZi();
   因为真实去的是孔子,所以teach讲课讲的内容是论语
   因为孔子和同学们关系很好,索引相约一起打王者
卸妆-->变成孔子的样子,因为孔子会打王者
   大范围类型   :父类       小范围类型: 子类
   KongZi z=(KongZi)k; --向下转型
   z.play();
   如果先要调用子类中新增的方法,需要向下转型
   ClassCastException 类型转换异常
   instanceof 运算符
   A引用 instanceof B
   判断A的引用是否为B类类型的对象,或者B类子类的对象,如果是返回true,否则返回false

public class CastDemo {
	public static void main(String[] args) {
		KongZiDie k=new KongZi();
		k.teach();
		//转型
		//KongZi z=(KongZi)k;
		//ClassCastException 类型转换异常
		if(k instanceof XiongDie){
			XiongDie x=(XiongDie)k;
			x.teach();
		}
		if(k instanceof Object){
			KongZi x=(KongZi)k;
			x.teach();
		}						
	}
}
class KongZiDie{
	String name;
	int age;	
	void teach(){
		System.out.println("做生意");
	}
}
class KongZi extends KongZiDie{
	void teach(){
		System.out.println("将论语");
	}	
	void play(){
		System.out.println("打王者");
	}
}
class XiongDie extends KongZiDie{
	void teach(){
		System.out.println("讲啦啦啦");
	}
}

八.抽象类

1.抽象类: 使用abstract修饰的类叫做抽象类
抽象方法:使用abstract的关键字修饰的方法
   抽象方法没有方法体的方法
   抽象方法必须存在于抽象类中
   2.java工程师: 行为:工作
   前端工程师:   行为:工作
   定义个父类 develop开发部类 --> 行为:工作
   注意:
   1)抽象类不是实例化 (创建对象)
   2)抽象方法必须被重写(子父类继承)
   3)如何使用抽象类中的内容:---创建具体子类的对象去使用
具体的子类:重写父类中所有的抽象方法+按需新增方法
   抽象的子类:按需重写父类中的抽象方法+按需新增-->抽象类,如果想要使用最终需要具体子类
3.抽象类中可以存在抽象方法,可以存在具体方法
4.abstract不能和private,final,static,native一起使用
5.抽象方法只需要被重写一次,也可以按需重写多次
接口:接口特殊的抽象类
类要继承 -->只能单继承
接口要实现 :吸烟 :游泳 --->多实现
   如果有一个人类会游泳实现游泳接口,会抽烟实现抽烟的接口,即会游泳又会抽象,同时实现这两个接口
只要实现了这个接口,就有了这个能力,
接口在jdk1.8之前只能存在抽象方法
6.为什么不用具体的类,要使用抽象类?
方法体不知道如何定义,需要抽象方法,需要抽象类
抽象类会了,接口很简单,为什么不用抽象类要用接口,接口有什么好处,接口概念是什么样的,接口要怎么用,用的时候有哪些注意事项?

咚痞子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE.20190430.权限修饰符.重写.super.final.object.转型.抽象类.面向对象的三大特征之一多态.

一.权限修饰符 1.权限修饰符本类同包类不同包子类不同包其他类私有的 private ✔ 默认的 default ✔ ✔ 受保护的 protected ✔ ✔ ✔ 公共的 public ✔ ...
复制链接

扫一扫

专栏目录