面向对象2一.gc垃圾回收机制二.package包和导包三.javabean 封装四.继承 ——extends五.权限修饰符六.override七.super八.final

66 阅读 0 评论 44 点赞

我是靠谱客的博主健壮缘分，最近开发中收集的这篇文章主要介绍面向对象2一.gc垃圾回收机制二.package包和导包三.javabean 封装四.继承 ——extends五.权限修饰符六.override七.super八.final，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一.gc垃圾回收机制

1)、jvm时刻监控堆中对象，按照一定的声明周期进行清理回收

2)、System.gc() ：起通知的作用，通知垃圾回收机制回收垃圾，但是是否回收，什么时候回收无法控制

其中一定会回收垃圾的情况：

匿名对象
对象无引用

3)、finalize() ：回收垃圾会先调用对象的这个方法

二.package包和导包

1)、定义

为了便于管理大型软件系统中数目众多的类，解决类的命
名冲突问题，Java 引入包(package)机制，提供类的多重类命名空间。

一般的命名为：公司域名倒写+功能名|模块名。

2)、package语句

指明该文件
中定义的类所在的包。（若缺省该语句，则指定为无名包）。

格式： package com.shsxt.test;（package 语句中，用’.’来指明包（目录）的层次）

注：:不要定义与 jdk 相同的包，相同的类，否则会引起很多莫名其妙的问题

3)、import

不需要使用 import 的类有:

语言包（java.lang）下的类
同包下的类

模糊匹配: 降低编译效率,不会减低运行效率如：java.util.*

静态导入: 只导入静态的内容如：import static java.lang.Math.PI;

三.javabean 封装

1)、定义

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和行为（或方法）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

2)、好处

隐藏实现细节，提供公共的访问方式（设置器(设置私有属性的值)setter、访问器(获取私有属性的值)getter ）
提高代码的复用性
提高代码的安全性

3)、javabean标准的开发要求

类应该是公共的
至少存在一个空构造
私有的属性
提供公共的访问方式:setter、getter

4)、private是封装的一种体现

私有是封装,但是封装不仅仅是私有,如：方法,类..都是封装的体现

//公共类
public class Student01 {
	public String name;
	private int age; 		//	私有的属性
	public String gender;
	
	//创建一个空构造
	public Student01() {
	}

	public Student01(String name, int age, String gender) {
		this.name = name;
		if(age>0 && age<=150){
			this.age = age;
		}else{
			System.out.println("年龄不合法!!!");
		}
		this.gender = gender;
	}
	//提供公共访问方式setter
	//age的设置器
	//返回值:不需要     参数:需要 
	public void setAge(int age){
		if(age>0 && age<=150){
			this.age = age;
		}else{
			System.out.println("年龄不合法!!!");
		}
	}
	//提供公共访问方式getter
	//age的访问器
	//返回值:需要 返回值int age			参数:不想要
	public int getAge(){
		return age;
	}
	
	public void info(){
		System.out.println(name+"->"+age+"-->"+gender);
	}
	
}

四.继承 ——extends

类：是一系列对象的共性，是对对象的抽象

父类: 是一系列类的共性，是对类的抽象

1)、格式

子类 extends 父类

2)、继承的优点

提高代码的复用性
子类一旦继承父类,就可以使用父类中的内容

注：一类父类可以被多个子类继承,但是一个子类只能继承一个父类,java是单继承机制,但是可以多实现

面向对象的设计原则之一: 开闭原则,对修改关闭,对扩展开放

单继承的优点:使用简单

单继承的缺点:不便于后期维护

class Person{
	public String name;
	public int age;
	public String gender;
	
	//休息
	public void sleep(){
		System.out.println(name+"正在休息...");
	}
}
//子类 学生继承父类 Person
class Student extends Person{
	public String subject;  //新增-->扩展
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	//学习
	public void study(){
		System.out.println(name+"正在敲代码...");
	}
}


//教师类
class Teacher extends Person{
	public int javaClass;  //教师所授课的班级
	
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	
	//讲课
	public void teach(){
		System.out.println(name+"正在讲课...");
	}
}

五.权限修饰符

1)、权限修饰符

权限修饰符：public、protected、private、default

修饰符	本类	同包类	不同包子类	不同包
private	Y
default(默认)	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

注：

成员修饰符,只能修饰成员,不能修饰局部
修饰类的权限修饰符:public ,default(默认的)（default 类只可以在同包被访问）
私有内容不能被继承,静态的可以被继承

//父类
package test;
public class test1Package {
	public int tPublic=5;
	private int tPrivate=10;
	protected int tProtected=15;
	int tDefault=20;
}
//不同包子类
package son1;
//导包
import test.test1Package;

class Test extends test1Package{
	public static void main(String[] args){
	//不能使用父类创建对象调用父类的成员
		Test t=new Test();
		System.out.println(t.tPublic);
		System.out.println(t.tPrivate);		//报错
		System.out.println(t.tProtected);
		System.out.println(t.tDefault);		//报错
		
	}
}
//同包子类
package test;

class Son extends test1Package{
	public static void main(String[] args){
		Son s=new Son();
		System.out.println(s.tPublic);
		System.out.println(s.tPrivate);		//报错
		System.out.println(s.tProtected);
		System.out.println(s.tDefault);
		}
}

六.override

1)、重写的条件

不同的类
继承|实现
方法签名相同（方法签名：(方法名+参数列表））

2)、作用

子类一旦重写父类中的某个方法,子类对象调用的是子类中重写的方法,对父类同名方法屏蔽

package test;

public class Override01 {
	public static void main(String[] args) {
		Son1 s1 =new Son1();
		s1.usp();
		//运行结果为hello,dad,myfather
	}
}


class Father1{
	public Father1 usp(){
		System.out.println("hello,child,my son");
		return null;
	}

}


class Son1 extends Father1{
//重写	
	
	public Son1 usp(){
		System.out.println("hello,dad,myfather");
		return null;
	}
	
}

3)、检查是否为重写方法

左侧出现向上的三角形
注解 Override @注解名

4)、不能被重写

private修饰的方法不能被重写
final修饰的内容不能被重写
被static修饰的内容不能被重写

注：如果子类中定义一个方法,在它的父类中有同名(方法签名)的静态方法,子类中的这个方法也必须是静态的

5)、重写的要求

== : 方法签名必须完全相等
<= : 返回值类型 : 基本数据类型必须相等, 引用数据类型:子类的返回值类型<=父类的返回值类型
>= : 子类重写方法的的权限修饰符必须>=父类中这个方法的权限修饰符

package test;

public class Override01 {
	public static void main(String[] args) {
		Son1 s1 =new Son1();
		s1.usp();
		s1.sp();
		s1.sp(0);
	}
}

class Father1{
//引用数据类型
	public Father1 usp(){
		System.out.println("hello,child,my son");
		return null;
	}
	//权限修饰符
	protected void sp(){
		System.out.println("hello,child,my son");
		
	}
}


class Son1 extends Father1{
//重写	
	//引用数据类型
	public Son1 usp(){
		System.out.println("hello,dad,myfather");
		return null;
	}
//	重写
	//子类权限修饰符public大于父类protected
	public void sp(){
		System.out.println("hello,dad,myfather");
		
	}
	//构成重载
	void sp(int a){
		System.out.println("重载");
	}
	
}

七.super

1)、super与this的区别

this：指代当前new的对象

super：指代父类对象

注：super和this不能同时存在,因为都要在首行，如果存在this(),会在this调用的构造器首行调用父类构造器

2)、作用

在子类构造器首行调用父类中的某个构造器

注：如果没有显示调用,默认在*首行*调用父类空构造,如果一旦显示调用,就不会默认调用父类空构造器了

3)、步骤

创建对象: 先父类后子类

初始化: 先静态后成员

public class SuperDemo01 {
	public static void main(String[] args) {
		
		Zi zi=new Zi(123);
		zi.test();
	}
}

class Fu{
	String name;
	int age;
	int a;
	public Fu() {
		System.out.println("我是父类空构造");
	}
	
	public Fu(String name,int age) {
		System.out.println("我是父类带参构造");
		this.name=name;
		this.age=age;
	}
	
}

class Zi extends Fu{
	int a;
	public Zi() {
		System.out.println("我是子类空构造");
	}
	
	public Zi(int a) {
		this.a=a;
	}
	
	public Zi(String name,int age) {
		//this();
		super(name,age);
		System.out.println("我是子类带参构造");
	}
	
	void test(){
		int a=333;
		//a是成员,只能通过对象调用,默认this调用就近原则指代当前类
		System.out.println(a);
		System.out.println(this.a);
		System.out.println(super.a);  //super指代父类对象
		
	}
	
}

八.final

final修饰的变量为常量

final修饰的方法不能被重写

final修饰的类不能被继承(太监类)

public class FinalDemo02 {
	final F a=new F();  //a永远执行后面的对象,存储的对象地址永远不能改变
	public static void main(String[] args) {
		//对象的地址不改变,内存空间的值可以改变
		new FinalDemo02().a.money=10;
		
		//new FinalDemo02().a=new F();  重新指向了
		
		FinalDemo02 f=new FinalDemo02();
		f=new FinalDemo02();
		
	}
}

class F{
	int money=100;
	public  void test(){
		
	}
}
class Z extends F{
	public  void test(){
		
	}
}

最后

以上就是健壮缘分为你收集整理的面向对象2一.gc垃圾回收机制二.package包和导包三.javabean 封装四.继承 ——extends五.权限修饰符六.override七.super八.final的全部内容，希望文章能够帮你解决面向对象2一.gc垃圾回收机制二.package包和导包三.javabean 封装四.继承 ——extends五.权限修饰符六.override七.super八.final所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：java语言初级
浏览次数：66 次浏览
发布日期：2023-09-05 15:15:34
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_10_f1_14_z_26_3.html

面向对象2一.gc垃圾回收机制二.package包和导包三.javabean 封装四.继承 ——extends五.权限修饰符六.override七.super八.final

概述

一.gc垃圾回收机制

二.package包和导包

1)、定义

2)、package语句

3)、import

三.javabean 封装

1)、定义

2)、好处

3)、javabean标准的开发要求

4)、private是封装的一种体现

四.继承 ——extends

1)、格式

2)、继承的优点

五.权限修饰符

1)、权限修饰符

六.override

1)、重写的条件

2)、作用

3)、检查是否为重写方法

4)、不能被重写

5)、重写的要求

七.super

1)、super与this的区别

2)、作用

3)、步骤

八.final

最后

评论列表共有 0 条评论

发表评论取消回复

面向对象2一.gc垃圾回收机制二.package包和导包三.javabean 封装四.继承 ——extends五.权限修饰符六.override七.super八.final

概述

一.gc垃圾回收机制

二.package包和导包

1)、定义

2)、package语句

3)、import

三.javabean 封装

1)、定义

2)、好处

3)、javabean标准的开发要求

4)、private是封装的一种体现

四.继承 ——extends

1)、格式

2)、继承的优点

五.权限修饰符

1)、权限修饰符

六.override

1)、重写的条件

2)、作用

3)、检查是否为重写方法

4)、不能被重写

5)、重写的要求

七.super

1)、super与this的区别

2)、作用

3)、步骤

八.final

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复