Java基础讲解-----（抽象类，final，接口，File类）

最新推荐文章于 2024-07-27 13:31:57 发布

不想睡醒的梦

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量265

点赞数 1

分类专栏： JAVA 文章标签： java 抽象类接口类其他

本文链接：https://blog.csdn.net/m0_52479012/article/details/115652952

版权

JAVA 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本篇文章是整合Java中的一些基础知识基本的类和一些语句的基础讲解特别适合一些新学Java的同学
注意本片博客会不定时进行更新，但是只更新已更新之外的知识代码

-----------------------------------------------------------------------------------------------------------------------------------------

抽象类概述

抽象类概念： 包含抽象方法的类，用abstract来进行修饰
抽象方法的概念： 抽象方法，只有方法声明，没有方法体的方法。同样用abstract来进行修饰。
抽象方法的由来： 当需要定义一个方法，却不明确用什么方法的具体实现时，可以将方法定义为abstract，具体实现延迟的它的子类。
**注意：**抽象类不一定有抽象方法，但有抽象方法的一定是抽象类。

抽象类的特点：

修饰符：必须通过 abstract 关键字来进行修饰。
公式1：（修饰类）修饰符abstract class 类名{}
公式2：（修饰成员方法）修饰符 abstract 返回类型方法名（）
抽象类不能被实例化，只能通过创建子类对象。（抽象的意思就是不具体，所以不能 new ）
抽象类子类的两个选择：
一：重写父类的所有抽象方法
二：把类定义为抽象类

抽象类成员的特点:

成员变量：
可以有普通的成员变量
也可以有成员常量
成员方法：
可以有普通方法，也可以有抽象方法
可以既可以有抽象方法，也可以有非抽象方法
有构造方法并且构造方法可以重载

先放一个代码然后再进行分析


abstract class fu {
		public fu(){};//定义一个空参构造
		public fu(String name) { //定义一个有参构造，并完成方法重载。
		 	this.name=name;
	 }
	 //成员变量
	 String name="章三";
	//int age 为变量  final int age 为成员常量  不能发生改变
	 final int age=60; 
	//定义一个吃的抽象类
	public abstract void eat();
	//定义一个睡的抽象类
	public abstract void sleep(); 
	//定义一个叫的非抽象方法
	public void call() {
		System.out.print("会叫");
	}
}
 class zi extends fu{
	 @Override //抽象子类如果是普通类必须重写父类所有抽象方法
	 public void eat() {
		 System.out.println("猫吃老鼠");
	 }
	 public void sleep() {
		 System.out.println("猫站着睡觉");
	 }
 }
 abstract class zhi extends fu{//抽象子类如果是抽象类可以不重写父类抽象方法
	 
 }
public  class bb{
	public static void main(String[] args) {
		//fu Fu = new fu();   抽象类不能实例化  （就是不能 new）
	//初始化抽象类
		fu test = new zi();
System.out.println("--------------------------------------");

}

抽象类特点代码解析

1：必须用修饰符abstract 关键字来进行修饰。
公式一：修饰类

abstract class fu {}

公式二：修饰方法

public abstract void eat();

2：抽象类不能被实例化，只能通过创建子类对象

public  class bb{
	public static void main(String[] args) {
		//fu Fu = new fu();   抽象类不能实例化  （就是不能 new）当出现这个对象时在此代码就会报错。
	//初始化抽象类，实现类必须通过子类。
		fu test = new zi();

抽象类子类的两个选择：
一：重写父类的所有抽象方法

class zi extends fu{
	 @Override //抽象子类如果是普通类必须重写父类所有抽象方法
	 public void eat() {
		 System.out.println("猫吃老鼠");
	 }
	 public void sleep() {
		 System.out.println("猫站着睡觉");
	 }
 }

二：把类定义为抽象类

 abstract class zhi extends fu{
 //抽象子类如果是抽象类可以不重写父类抽象方法
	 }

抽象类成员的特点解析

成员变量：
一：可以有普通的成员变量

String name="章三";

二：也可以有成员常量

	 final int age=60; 
	 //int age 为变量  final int age 为成员常量  不能发生改变

成员方法：
一：可以有普通方法，也可以有抽象方法

 class zi extends fu{
	 @Override //抽象子类如果是普通类必须重写父类所有抽象方法
	 public void eat() {
		 System.out.println("猫吃老鼠");
	 }
	 public void sleep() {
		 System.out.println("猫站着睡觉");
	 }
 }
 abstract class zhi extends fu{//抽象子类如果是抽象类可以不重写父类抽象方法
	 
 }

二：可以既可以有抽象方法，也可以有非抽象方法

public abstract void eat();
	//定义一个睡的抽象类
	public abstract void sleep(); 
	//定义一个叫的非抽象方法
	public void call() {
		System.out.print("会叫");
	}

三：有构造方法并且构造方法可以重载

public fu(){};//定义一个空参构造
public fu(String name) { //定义一个有参构造，并完成方法重载。
	this.name=name;

---------------------------------------------------------------------------------------------------------------------------------

final讲解

final概念：最终的，最后的

final作用：用于修饰类，方法和变量

final的作用解析：

1：修饰类：该类不能被继承，也就是说该类不能有子类。

2：修饰方法：该方法不能被重写
注意：final不能与abstract共存，因为被abstract修饰的方法子类必须重写，但是final修是的方法不能被重写。

3：修饰变量：最终变量，即常量，只能赋值一次。
注意：当修饰引用类型数据，因为仍然可以通过引用修改对象的内部数据，意义不大

代码解析

1：修饰类

final class fu{}
class zi extends fu {}  //这样这样写时，代码就会报错
----------------------------------------
//但是父类fu可以继承grandma ，也就是说fu这个类可以有爸爸但是没有儿子
final class fu extends grandma{}
class grandma{}

1：修饰方法

final class fu{
	public final void show(){
		system.out.println("好爸爸");
		}
}
class zi extends fu {
	@override
	public void show(){   //代码这样写就会报错，说明当final定义方法时，子类不可以进行方法重写
		system.out.println("好妈妈");
		}
}

1：修饰变量

final int NUM= 30;
//修改NUM值时
NUM=10; //此代码就会报错，表明通过final定义的变量变成常量，只能进行赋值一次，再次修改值时就会报错

拓展：final 修饰的变量：引用类型的变量，是地址值不能改变，但是属性值可以发生改变。

class mm{
String name="张三";
int age=4;
}
final mm nn = new mm();
system.out.println(mm.name);
system.out.println(mm.age);
//nn = new mm(); 当出现这行代码是就会报错，final 修饰的变量是不允许地址值发生改变，当再次new 的时候地址值发生改变，代码报错：这就是地址值不能改变

//但是属性值可以发生改变，没有太大的意义，一般也不用，了解即可。
mm.name="张无忌";
mm.age=15;

system.out.println(mm.name);
system.out.println(mm.age);
最后的输出是     //这是属性值发生改变
张三
4
张无忌
15

---------------------------------------------------------------------------------------------------------------------------------

JAVA --接口基础讲解

接口概念：它是用于描述类具有什么功能，但并不给出具体实现，类要遵从接口描述的同一规则进行定义，所以，接口是对外提供的一组规则和标准。是一个特殊的抽象类，接口中的所有方法都没有方法体。

接口的定义:

1：语法格式：[修饰符] interface 接口名 [ extends 父接口名列表]{}
注意：被[ ] 定义的都是可选的，有或者没有都可以。
2：类和接口是实现关系，用implements 类表示
class 类名 implements 接口名
注意：接口修饰的成员方法中都有默认的修饰方法 public abstract
想要在接口的实现类中的方法实现，必须出现方法重写

以下代码都是对于定义的解析：

public class interfacev {  

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		mc in = new mc();
		in.smoking();
	}


 interface md {		
	public abstract  void smoking();
}
class mc implements md{
	public void smoking(){
		System.out.println("吸烟有害健康");
	}
}

接口创建对象的特点：

1：接口不能实例化（就是不能new的意思）通过多态的方式实例化子类对象

interface a{}
class b implements a{}
//a test = new test();   这种是错误的创建对象方法，因为定义 a 为接口
a test = new b();  //这种创建对象的方法是正确的，通过多态的方法实现

2：接口的子类（实现类）可以是抽象类：可以不重写接口中的抽象方法了
也可以是普通类：必须重写接口中所有的抽象方法

interface v{
	public abstract void call();
	public abstract void sell();
	
}
abstract class vv implements v{}
class vvv implements v{
	public void call() {
		System.out.println("打电话");
	}
	public void sell() {
		System.out.println("卖水果");
	}
}

接口继承关系的特点：

接口与类是实现的关系

接口与接口之间的关系
继承关系，可以是单继承或者是多继承关系（格式接口 extends接口1，接口2…

继承与实现的区别：
1:继承是体现 is a的关系，在父类中定义共性的内容
2:实现体现的是like a的关系，接口中定义扩展功能
举例介绍：在动物类中马狗猪猴子都有名字都睡觉都吃饭这是共性内容，把这些定义在父类中。在日后，猴子有了爬树的功能，而这就是定义在接口中。

接口的成员特点：

1：成员变量的特点：接口没有成员变量，只有公有的.静态的常量
接口会有默认值（public static final)常量名=常量值
2：接口成员方法特点
（JDK7及以前）公有的，抽象方法：
public sbstract 返回值类型方法名（）；
（JDK8以后）可以有默认方法和静态方法：
默认 public default 返回值类型方法名（）{}
静态 static 返回值类型方法名（）{}
（JDK9以后）可以有私有方法：
private 返回值类型方法名（）{}
3：接口构造方法的特点：
接口不能实例化，也没有初始化的成员所以没有构造方法

public class chengyuantedian {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//usb.num=20;  1：成员变量的特点：接口没有成员变量，只有公有的.静态的常量，接口会有默认值（public static final)常量名=常量值
		System.out.println(usb.num);
		
	}
}
interface usb{
	//public static final 默认代码前面有这些
	int num=10;
	//JDK7及以前 有公有的抽象方法
	public abstract void close();
	
	//JDK8 多了默认方法和静态方法
	public default void close1() {
		System.out.println("我是默认");
	}
	static void close2() {
		System.out.print("我是静态");
	}
	
	//JDK9 多了私有方法
	private void close3() {
		System.out.println("这是9的私有方法");
	}
	//public usb(){}  接口不能定义构造方法
}

---------------------------------------------------------------------------------------------------------------------------------

File类：

概述：文件.文件夹，一个File对象代表磁盘上的文件或者文件夹。（就是用来操作文件（夹）的路径）

一：构造方法：

File （String pathname) : 根据给定的字符串路径创建其对应File对象。
File (String parent , String child) :根据给定的字符串形式的父目录和子文件夹（夹）名创建File 对象。
File （String parent ， String child) ：根据给定的父目录对象和子文件（夹）名创建File对象。

二：成员方法：

创建功能：
createNewFile(): 创建文件
mkdir（）：创建单级目录
mkdirs（）：创建目录

判断功能：
isDirectory(): 判断File 对象是否为目录
isFile():判断File对象是否为文件
exists():判断File对象是否存在

代码讲解：

File file1 = new File("d:/my/1.txt");
		System.out.println(file1);
		
		
		File file2 = new File("d:","/my/1.txt");
		System.out.println(file2);
		
		File file3 =new File("d:");
		File file4 = new File(file3,"1.txt");
		System.out.println(file4);
		System.out.println("---------------------------------------");
		//创建功能
		File file5 = new File("d:/my/2.txt"); //方法一
		boolean test1 =file5.createNewFile();
		System.out.println(test1);
		
		File file6 = new File("d:/my/a");     //方法二
		boolean test2 = file6.mkdir();
		System.out.println(test2);
		
		File file9 = new File("d:/my/b/c");   //方法三
		boolean test3 = file9.mkdirs();
		System.out.println(test3);
		
		System.out.println("---------------------------------------");
		
		//判断功能
		File file10 = new File("d:/my/1.tst"); //判断此路径的文件是否为目录
		boolean test4=file10.isDirectory();
		System.out.println("test4:"+file10);
		
		File file11 = new File("d:/my/b/c");  //判断此路径是否为文件
		boolean test5 = file11.isFile();
		System.out.println(test5);
		
		File file12 = new File("d:/my/b/c"); //判断此路径是否存在
		boolean test6 = file11.exists();
		System.out.println(test6);
输出结果：           //注意：在判断.和创建功能上最后的输出结果为BOOLEAN 型，所以最后输出的要么是TRUE或者是FALSE

d:\my\1.txt
d:\my\1.txt
d:1.txt
---------------------------------------
false
false
false
---------------------------------------
test4:d:\my\1.tst
false
true

判断功能
getAbsolutePath(): 获取绝对路径
gePath(); 获取文件的相对路径
getname(); 获取文件名
list(); 获取指定目录下所有文件（夹）名称数组
listFiles(); 获取指定目录下所有文件（夹）file数组
Java 中的路径的划分
绝对路径：
以盘符开头的路径，固定的，写（死）的路径。
相对路径：
相对某个路径而言，Java中的相对路径是指相对于当前项目路径来讲的

代码解释：
注意：此代码文件的建立在同一个文件下面。（看情况写路径）

				File filee1 = new File("test/1.txt");
			
			//获取绝对路径
				String path1 = filee1.getAbsolutePath();
				System.out.println("绝对路径："+path1);
			//获取相对名称	
				String path2 = filee1.getPath();
				System.out.println("相对路径："+path2);
			//获取文件名
				String name1 = filee1.getName();
				System.out.println(name1);
			// 获取指定目录下所有文件（夹）名称数组
				File filee2 = new File("test");
				String[] list = filee2.list();
				for (String name:list) {
					System.out.println(name);
			//获取指定目录下所有文件（夹）file数组
				File[] listFiles = filee2.listFiles();
				for(File names:listFiles) {
				System.out.println(names);
			//区别在于可以直接调用方法
				System.out.println(names.isDirectory());
				}

如果想要更多的了解请关注后期的动态

不想睡醒的梦

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础讲解-----（抽象类，final，接口，File类）

本篇文章是整合Java中的一些基础知识基本的类和一些语句的基础讲解特别适合一些新学Java的同学注意本片博客会不定时进行更新，但是只更新已更新之外的知识代码-----------------------------------------------------------------------------------------------------------------------------------------抽象类概述抽象类概念：包含抽象方法的类，用abstract来进行修饰
复制链接

扫一扫