JavaSE进阶

iiiis310

已于 2022-04-04 12:14:36 修改

阅读量3.9k

点赞数

文章标签： java

于 2022-04-03 19:48:28 首次发布

本文链接：https://blog.csdn.net/weixin_46818691/article/details/123911308

版权

1、使用集成开发工具eclipse

1.1、java的集成开发工具很多，包括：eclipse、Intellij IDEA、netbeans.....

       eclipse：
           IBM开发的。eclipse翻译为：日食。寓意吞并SUN公司（SUN是太阳。）
           最终没有成功，SUN公司在2009年的时候被oracle甲骨文公司收购。
           eclipse在以前的开发中使用非常多，但是由于IDEA工具的出现，让eclipse
           的用户大大减少，目前eclipse占市场份额30%。IDEA占市场份额60%，
           剩下10%是其他的开发工具。

       Intellij IDEA：
           提示功能比eclipse强大。更好用。

   1.2、什么是集成开发工具？
       集成开发工具又称为集成开发环境，把开发中需要的东西全部集成在一起，
       包括编写代码时大量的代码提示，及时的编译，程序员编写代码之后，集成
       开发工具自动编译，有语法错误的时候集成开发工具会马上标红色。运行的
       时候也不需要命令，直接使用鼠标操作即可。总之集成开发工具就是为了提高
       开发速度。另外集成开发工具会为程序员生成很多代码，有很多代码不需要写。
           及时编译
           语法错误及时提醒
           代码提示功能
           代码自动生成功能
           方便的运行
           .....

   1.3、eclipse的安装：
       我的eclipse是一个解压版的。直接解压就能用。
       使用当前的这个eclipse的时候，需要计算机上已经安装了JDK，并且bin目录已经配置到path当中。
       解压之后：eclipse.exe 是启动eclipse开发工具的。

   1.4、eclipse工具的使用
       * 第一次打开eclipse的时候，会让你选择工作区，工作区就是java代码存放的位置。
           默认位置：C:\Users\Administrator\eclipse-workspace
           你可以修改成其他位置，没问题。
           我这里改一下：D:\course\JavaProjects\02-JavaSE\eclipsecode
           选择工作区的窗口左下角有一个复选框：
               这个复选框选中表示下一次再打开eclipse的时候默认进入这个工作区。不再询问。
               我这里就不选中了。（让他每一次询问。）

* 打开之后，会呈现一个：welcome，（直接关闭即可）

       * 关闭welcome之后，默认的布局方式：javaee方式，我们目前是javase，怎么切换
       布局方式到javase呢？
           点击右上角倒数第二个小图标，打开一个窗口，选择java。

       * 我把这个javase布局中所有没有用的窗口全部关闭：
           只留下：package explorer
           一不小心把：package explorer关闭了怎么办？
               可以再打开：window菜单 --> show view--> package explorer

       * 一个布局打乱了，能重置吗？手机恢复出厂设置....
           window菜单 --> Perspective --> reset.....

       * 在eclipse的workspace工作区当中以project（工程）为单位。所以要编写
       java代码，必须先新建工程。在工程上编写代码：
           怎么创建工程？
               在package explorer窗口的空白位置右键 --> new --> java project

           新建工程（java project）的时候：
               需要指定：
                   工程的名字：我这里起名javase
                   选择JRE，当前eclipse默认选择的是JRE11.(我电脑上没有，这个应该是eclipse自带的。)
                   JRE(java的运行环境。)
               目前为止：大家只要指定工程名字就行，别的不用修改。
               直接finish，就新建工程完成了。

           注意：最后一步finish的时候，会提醒你是否创建java文件，可以创建，也可以不创建。

       * 怎么删除工程？
           工程上右键--> delete --> 弹出窗口之后，选中复选框表示彻底删除（硬盘上也删了。）

       * 编写第一个HelloWorld程序
           在src上点击右键--> new --> Class :
               填写上类名：HelloWorld
               在下面有一个选中创建main方法。选中表示自动创建main方法。
               finish完成。

       * 出现了兼容问题：
           eclipse（2018-12的版本），不支持JDK11以及更高版本。
           我这里先这样处理一下：下载一个低版本的JDK，选择JDK8.

       * 安装了JDK8之后，再重新在eclipse中创建java project。
           怎么在eclipse当中指定使用某个JRE/JDK呢？
               在新建工程的窗口上有一个：Configure jres....
               弹出的窗口中：add
               add之后选择：standard vm
               然后next
               在弹出的窗口中点击：Directory
               目录选中这个即可：C:\Program Files\Java\jdk1.8.0_101
               别的位置不用动。
               finish.
               完成的过程中：你要记得把jdk8的对勾打上。
               apply and close...

       * 一会我给大家分享一个高版本的eclipse。能够让eclipse支持高版本的JDK。

       * eclipse设置字体：
           window菜单--->最后一个-->窗口上输入font-->选中color and font
           --> basic --> 最后一个双击。

       * eclipse是实时编译的，有语法错误会报红。

* 注意：eclipse有的时候是必须保存之后才会编译的。要时刻ctrl + s

       * main方法怎么生成？
           main，然后alt + /

       * System.out.println()怎么生成？
           sysout ，然后atl + /

       * 怎么运行：
           在有main方法的程序上右键 --> run as --> java application..

       * 怎么生成构造方法
           在空白处右键 --> source --> generate constructor

       * 怎么生成set和get方法
           在空白处右键 --> source --> generate setter and getter

       * eclipse默认情况下，当你“点”的时候都会有提示。

2、回顾从面向对象开始到目前讲解的位置，将所有的结论总结出来。

2.1、强调一下学习方法

       第一：上课过程中要记笔记（但是笔记一定要记简笔），笔记上最好没有废话，
       笔记上记的全是结论。有一些是需要死记硬背的，有一些是需要理解记忆的。
       总之最后不管是死记硬背还是理解记忆，都是需要“记忆”的。（听课不走神，
       集中精力捕捉重点结论。）

第二：课下整理笔记（快速的整理），一天的笔记整理要在30分钟之内完成。

       第三：别抄老师代码。根据笔记上整理的重要“结论”，一个结论一个结论去验证，
       验证这个结论的时候，写属于自己的代码。（验证的时候脑子要灵光一些，这样
       试验一下，那样试验一下，想尽一切办法推翻结论，如果最终结论没有被推翻，
       说明这个结论没毛病。）

       第四：只有上课中所有的结论都已经验证完毕了，你剩下的时间再去考虑作业题。
       作业题做不做都行，作业是次要的，课堂上的结论是重要的。

   2.2、回顾所有结论

       第八章重点以及结论：
           重点：
               什么是类？一个模板
               什么是对象？真实存在的，通过模板创建的
               什么是实例？对象就是实例
               怎么定义类？

           结论：
               定义类的语法机制：
                   [修饰符列表] class 类名 {
                       类体 = 属性+方法;
                   }
               属性来源于状态（属性描述状态）
               方法来源于动作（方法描述动作）

           课下思考：
               现实生活中有哪些对象？
               对象上有哪些属性？
               对象有什么行为？
               如果用java代码应该怎么描述？

       第九章对象的创建和使用

重点以及结论：

怎么创建对象？
new 类名();

               怎么使用对象？
                   需要将创建的对象赋值给一个变量。
                   而这个变量被称为引用。
                   怎么使用对象？“引用.”，死记硬背，使用对象的时候，就用“引用.”就行了。

               构造方法怎么定义？
                   语法需要记忆：
                       [修饰符列表] 构造方法名(形参){
                           构造方法体;
                       }

               构造方法怎么调用？
                   new
                   语法： new 构造方法名(实参);

构造方法的方法体中写什么？
给属性赋值。

               构造方法的重要结论：
                   一个类没有提供任何构造方法，会有一个默认的无参的。
                   一个类提供了构造方法，系统就不再默认提供无参构造了。
                   建议把无参构造写出来。

空指针异常怎么发生的？
“空引用”访问“实例”相关的就会出现空指针异常。

               方法调用时参数是怎么传递的？
                   方法调用的时候参数传递一定是将变量中保存的那个值
                   复制一份传过去。可能这个值是100，可能这个值是一个
                   对象的内存地址：0x1234

               一个java程序执行过程的内存图（对象的创建）？（实在搞不定就放弃先。）

       第十章封装
           重点以及结论？
               怎么封装：
                   属性私有化
                   对外提供公开的set和get方法

       第十一章 this关键字和static关键字
           static的重点以及结论
               static修饰的方法静态方法
               static修饰的变量静态变量
               static修饰的都用“类名.”访问。（都不需要new对象，就能访问）
               static{} 是静态代码块，在类加载时执行，并执行一次。
               {} 实例语句块，在构造方法执行前执行，构造一次执行一次。

static的也能用“引用.”的方式访问，不过运行时仍然和此对象无关，
空指针异常充分的说明了以上的结论。（用空引用访问静态的不会出现空指针异常）

           this的重点以及结论
               this用法就两个：this. 和 this()
               this不能用在静态方法中。只能使用在实例方法中。
               this. 大部分可以省略，区分局部变量和实例变量的时候不能省略。
               this() 只能出现在构造方法第一行，通过当前构造方法调用本类其它构造方法，代码复用。

       第十二章继承
           重点以及结论
               语法怎么实现？
                   extends关键字
               单继承
               默认继承Object
               自己验证一下子类继承父类之后，用子类能不能调用继承过来的方法。

第十三章方法覆盖和多态

方法覆盖的重点以及结论

               代码怎么写方法就能覆盖。
                   继承关系需要有
                   相同的返回值类型，相同的方法名，相同参数列表。

方法覆盖之后，子类对象执行的一定是覆盖之后的方法。
结论写出来了，你需要自己编代码验证一下这个结论是否正确。

           多态的重点以及结论
               无论向上转型还是向下转型，都要有继承关系。
               Animal a = new Cat();
               a.move(); 编译阶段和运行阶段绑定的move方法不一样。（向上转型）

               if(a instanceof Cat){ // 什么时候必须向下转型？？？？
                   Cat c = (Cat)a; // 向下转型之前养成什么好习惯？？？
               }

               有同学有疑问？
                   我不理解怎么用！！！！
                   以后到处都用多态，你只要记住这个就行。
                   心里一直想着一件事：能用多态就用多态。。。。。
                   尽量使用。用着用着你就明白了。。。。。。
                   我最初学习多态的时候也不理解多态有什么用。。。

               放弃式的学习要会！！！！！不会的先放一放，凑合能让自己代码编写就行。

       第十四章 super

重点以及结论

super的用法：super. 和 super()

super. 大部分可以省略，当父子都有相同的属性和方法时，
在子类中访问父类的特征时，必须使用super.

一个构造方法第一行啥也没有，自动会有一个super()

super不能出现在静态方法中，只能是实例方法。

super()是干啥的：是通过子类的构造方法调用父类的构造方法。

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

3、IDEA工具

1、关于java的集成开发环境：
eclipse、IntelliJ IDEA等。
其中目前主流的集成开发环境是：IntelliJ IDEA

   这只是一个工具，不要让一个工具把你难住了。
   开发工具不要使用汉化版，太low。
   英语单词太多别害怕，记位置。（一共就那几个主要的操作位置。）

2、安装IDEA工具
自己课下按照破解文档进行破解。

3、IDEA工具的使用：

   第一次打开的时候：会弹出一个窗口（import idea settings）
       这个表示导入idea的设置，但我们是第一次使用idea工具，
       没有设置过idea，所以这里选择：do not import setting...不导入设置。

   第二步：会让你接受条款，接受即可。

   第三步：don't send

第四步：一直下一步（最终选择免费试用30天。）

第五步：可能会让你填写email等信息，这里不填写，继续continue。

   第六步：弹出welcome窗口
       点击create new project
       注意：在IDEA当中一个project相当于eclipse当中的一个workspace。

   第七步：新建一个Empty Project
       新建一个空的工程，选择创建工程窗口下面“最后的那一项”，Empty Project

   第八步：给空的工程起一个名字：javase
       存储到：C:\Users\Administrator\IdeaProjects\javase
       点击finish。

   第九步：自动弹出一个每日提示，这个每日提示可以取消掉。以后每一次打开就不再提示了。

第十步：会自动弹出一个：project structure，这个窗口先取消掉。

   第十一步：在空的工程下新建Module（模块），IDEA中模块类似于eclipse当中的project。
       eclipse的组织方式：
           workspace--> project
       idea的组织方式：
           project --> module

       怎么创建module?
           file菜单-->new --> Module

   第十二步：在New Module窗口上点击左上角的java，然后next

第十三步：给module起一个名字：chapter15

第十四步：编写代码，在src目录下新建类，写代码，并运行。

4、关于IDEA工具的快捷键以及一些简单的设置

   4.1、字体设置
       file --> settings --> 输入font --> 设置字体样式以及字号大小。

   4.2、快速生成main方法
       psvm

   4.3、快速生成System.out.println()
       sout

   4.4、注意：IDEA是自动保存，不需要ctrl + s

   4.5、删除一行
       ctrl + y

   4.6、怎么运行：
       代码上右键-->run
       或者点击左侧的绿色箭头。
       ctrl + shift + F10

   4.7、左侧窗口中的列表怎么展开？怎么关闭？
       左箭头关闭。
       右箭头展开。
       上下箭头移动。

   4.8、idea中退出任何窗口，都可以使用esc键盘。（esc就是退出）

   4.9、任何新增/新建/添加的快捷键是：
       alt + insert

   4.10、窗口变大，变小：
       ctrl + shift + F12

   4.11、切换java程序：从HelloWorld切换到User
       alt + 右箭头
       或者
       alt + 左箭头

   4.12、切换窗口：
       alt + 标号
       alt + 1（打开，关闭）
       alt + 2

4.13、提示方法的参数：ctrl + p

   4.14、注释：
       单行注释：ctrl + /
       多行注释：ctrl + shift + /

   4.15、idea中怎么定位方法/属性/变量？
       光标停到某个单词的下面，这个单词可能是：
           方法名、变量名
       停到单词下面之后，按ctrl键，出现下划线，点击跳转。

4.16、idea当中复制一行是ctrl + d

4、final关键字

day20课堂笔记

1、final关键字
   1.1、final修饰的类无法继承。拓：String类不能继承
   1.2、final修饰的方法无法被覆盖、无法被重写。
   1.3、final修饰的局部变量只能赋一次值，不能再重新赋值。
   1.4、final修饰的引用（变量）一旦指向某个对象，则不能再重新指向其它对象，（地址不能变，变为null也不行），但是该引用指向的对象内部的数据是可以修改的。并且在方法执行过程中，该引用指向对象后，该对象不会被垃圾回收期回收，直到当前方法执行结束，才会释放空间
   1.5、final修饰的实例变量必须手动初始化，不能采用系统默认值，赶在系统赋默认值之前手动赋值就行（实例变量如果没有手动赋值的情况下，系统会默认赋值）

实例变量在什么时候赋值（初始化）：构造方法执行的过程中赋值。（new对象的时候）
1.6、final修饰的实例变量一般和static联合使用，称为常量。

常量：实际上和静态变量一样，常量和静态变量，都是存储在方法区，并且都是在类加载时初始化

区别在于：常量的值不能变

常量名建议全部都大写，每个单词之间用下划线衔接。

常量一般都是公开的（public）公开你也该不了

1.7、final控制不能调用的问题。final修饰表示最后的，不能变的，不能改的

5、抽象类和接口以及抽象类和接口的区别

   2.1、抽象类
       第一：抽象类怎么定义？在class前添加abstract关键字就行了。
       第二：抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
       第三：final和abstract不能联合使用，这两个关键字是对立的。
       第四：抽象类的子类可以是抽象类。也可以是非抽象类。
       第五：抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
       第六：抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
       第七：抽象方法怎么定义？
           public abstract void doSome();
       第八（*****五颗星）：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现，语法规定，否则编译报错。一个抽象的类继承一个抽象类倒是可以不重写

到目前为止，只是学习了抽象类的基础语法，一个类到底声明为抽象还是非抽象，
这个以后慢慢来吧。写代码多的时候，自然就理解了。

       面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。
           不对，错误的。
           Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们
           都不是抽象方法，例如：
               public native int hashCode();
               这个方法底层调用了C++写的动态链接库程序。
               前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

/*
	
	类到对象是实例化。对象到类是抽象。

	抽象类：
		1、什么是抽象类？
			类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
			类本身是不存在的，所以抽象类无法创建对象《无法实例化》。

		2、抽象类属于什么类型？
			抽象类也属于引用数据类型。

		3、抽象类怎么定义？《能把基础语法先学会》
			语法：
				[修饰符列表] abstract class 类名{
					类体;
				}
		
		4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。

		5、final和abstract不能联合使用，这两个关键字是对立的。

		6、抽象类的子类可以是抽象类。也可以是非抽象类。

		7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。

		8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？
			抽象方法表示没有实现的方法，没有方法体的方法。例如：
				public abstract void doSome();
				抽象方法特点是：
					特点1：没有方法体，以分号结尾。
					特点2：前面修饰符列表中有abstract关键字。
		
		9、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
*/
public class AbstractTest01{ 
	public static void main(String[] args){
		// 错误: Account是抽象的; 无法实例化
		//Account act = new Account();
	}
}

// 银行账户类
//错误: 非法的修饰符组合: abstract和final
/*
final abstract class Account{

}
*/

abstract class Account{
	/*
	public Account(){
	
	}
	public Account(String s){
	
	}
	*/
	// 非抽象方法
	public void doOther(){
	
	}

	// 抽象方法
	public abstract void withdraw();
}

// 子类继承抽象类，子类可以实例化对象
/*
class CreditAccount extends Account{
	public CreditAccount(){
		super();
	}
}
*/

// 抽象类的子类可以是抽象类吗？可以
/*
abstract class CreditAccount extends Account{

}
*/

/*
	抽象类：

		1、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。

		2、重要结论：重要结论五颗星*****（必须记住）
			一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。
			这是java语法上强行规定的，必须的，不然编译器就报错了。
			
			这里的覆盖或者说重写，也可以叫做实现。（对抽象的实现。）

*/
public class AbstractTest02{
	public static void main(String[] args){
		// 能不能使用多态?
		// 父类型引用指向子类型对象。
		Animal a = new Bird();  // 向上转型。（自动类型转换）

		// 这就是面向抽象编程。
		// 以后你都是调用的a.XXXX
		// a的类型是Animal，Animal是抽象的
		// 面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。
		// 这种编程思想符合OCP原则。
		/*
			分析以下：
				编译的时候这个move()方法是谁的？--animal
				运行的时候这个move()方法又是谁的？--bird
		*/
		a.move();

	}
}

// 动物类（抽象类）
abstract class Animal{

	// 抽象方法
	public abstract void move();
}

// 子类（非抽象的）
// 错误: Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()
/*
class Bird extends Animal{
}
*/

class Bird extends Animal{
	// 需要将从父类中继承过来的抽象方法进行覆盖/重写，或者也可以叫做“实现”。
	// 把抽象的方法实现了。
	public void move(){
		System.out.println("鸟儿在飞翔！");
	}
}


// 如果Bird是抽象类的话，那么这个Animal中继承过来的抽象方法也可以不去重写/覆盖/实现。
/*
abstract class Bird extends Animal{
}
*/
	

/*
	有些内容不要死记硬背，讲讲道理。
	分析：
		Animal是父类，并且是 抽象的。
		Animal这个抽象类中有一个抽象方法move。

		Bird是子类，并且是 非抽象的。
		Bird继承Animal之后，会将抽象方法继承过来。

*/

   2.2、接口的基础语法。
       1、接口是一种“引用数据类型”。
       2、接口是完全抽象的。
       3、接口怎么定义：[修饰符列表] interface 接口名{}
       4、接口支持多继承。（一个接口继承多个接口）
       5、接口中只有常量+抽象方法。
       6、接口中所有的元素都是public修饰的
       7、接口中抽象方法的public abstract可以省略。
       8、接口中常量的public static final可以省略。
       9、接口中方法不能有方法体。

/*
	接口：
		1、接口也是一种“引用数据类型”。编译之后也是一个class字节码文件。
		2、接口是完全抽象的。（抽象类是半抽象。）或者也可以说接口是特殊的抽象类。
		3、接口怎么定义，语法是什么？
			[修饰符列表] interface 接口名{}
		4、接口支持多继承，一个接口可以继承多个接口。
		5、接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。接口中没有其它内容了。只有以上两部分。
		6、接口中所有的元素都是public修饰的。（都是公开的。）
		7、接口中的抽象方法定义时：public abstract修饰符可以省略。
		8、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。
		9、接口中的常量的public static final可以省略。
*/
public class Test01{
	public static void main(String[] args){

		// 访问接口的常量。
		System.out.println(MyMath.PI);

		// 常量能重新赋值吗？
		//错误: 无法为最终变量PI分配值
		//MyMath.PI = 3.1415928;

		//错误: 无法为最终变量k分配值
		//MyMath.k = 111;
	}
}

// 定义接口
interface A{

}

// 接口支持继承
interface B extends A{

}

// 一个接口可以继承多个接口（支持多继承）
interface C extends A, B{
}

// 我的数学接口
interface MyMath{

	// 常量
	//public static final double PI = 3.1415926;

	// public static final可以省略吗？
	double PI = 3.1415926;

	// k是不是常量？？？？是。
	// 接口中随便写一个变量就是常量。
	// 常量：值不能发生改变的变量。
	int k = 100;

	// 抽象方法
	//public abstract int sum(int a, int b);

	// 接口当中既然都是抽象方法，那么在编写代码的时候，public abstract可以省略吗？
	int sum(int a, int b);

	// 接口中的方法可以有方法体吗？
	// 错误: 接口抽象方法不能带有主体
	/*
	void doSome(){
	
	}
	*/

	// 相减的抽象方法
	int sub(int a, int b);

}

6、抽象类和接口以及抽象类和接口的区别2

1.1、抽象类的基础语法（见昨天笔记）

   1.2、接口的基础语法
       1、接口是一种“引用数据类型”。
       2、接口是完全抽象的。
       3、接口怎么定义：[修饰符列表] interface 接口名{}
       4、接口支持多继承。
       5、接口中只有常量+抽象方法。
       6、接口中所有的元素都是public修饰的
       7、接口中抽象方法的public abstract可以省略。
       8、接口中常量的public static final可以省略。
       9、接口中方法不能有方法体。
       10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。
       11、一个类可以实现多个接口。
       12、extends和implements可以共存，extends在前，implements在后。
       13、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。

/*
	接口的基础语法：
		1、类和类之间叫做继承，类和接口之间叫做实现,接口和接口之间叫继承。
		别多想：你仍然可以将"实现"看做“继承”。
		继承使用extends关键字完成。
		实现使用implements关键字完成。

		2、五颗星（*****）：当一个非抽象的类实现接口的话，必须将接口中所有的
		抽象方法全部实现（覆盖、重写）。
*/
public class Test02{
	public static void main(String[] args){
		//错误: MyMath是抽象的; 无法实例化
		//new MyMath();

		// 能使用多态吗？可以。
		//Animal a = new Cat();

		// 父类型的引用指向子类型的对象
		MyMath mm = new MyMathImpl();
		// 调用接口里面的方法（面向接口编程。）
		int result1 = mm.sum(10, 20);
		System.out.println(result1);

		int result2 = mm.sub(20, 10);
		System.out.println(result2);
	}
}

// 特殊的抽象类，完全抽象的，叫做接口。
interface MyMath{
	double PI = 3.1415926;
	int sum(int a, int b);
	int sub(int a, int b);
}

// 这样没问题
/*
abstract class MyMathImpl implements MyMath {
}
*/

// 编写一个类（这个类是一个“非抽象”的类）
// 这个类的名字是随意的。
//错误: MyMathImpl不是抽象的, 并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class MyMathImpl implements MyMath {
}
*/

//修正
class MyMathImpl implements MyMath {

	//错误：正在尝试分配更低的访问权限; 以前为public
	/*
	int sum(int a, int b){
		return a + b;
	}
	*/

	// 重写/覆盖/实现 接口中的方法（通常叫做实现。）
	public int sum(int a, int b){
		return a + b;
	}

	public int sub(int a, int b){
		return a - b;
	}
}


/*
	接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？

		对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，
		一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....
	

	重点（五颗星*****）：一个类可以同时实现多个接口。

	这种机制弥补了java中的哪个缺陷？
		java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中
		存在多继承，java中的接口弥补了单继承带来的缺陷。
	
	接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。
	编译器没意见。但是运行时可能出现：ClassCastException

	之前有一个结论：
		无论向上转型还是向下转型，两种类型之间必须要有继承关系，
		没有继承关系编译器会报错。（这句话不适用在接口方面。）
		最终实际上和之前还是一样，需要加：instanceof运算符进行判断。
		向上转型养成好习惯。转型之前先if+instanceof进行判断。
*/
public class Test03{
	public static void main(String[] args){
		// 多态该怎么用呢？
		// 都是父类型引用指向子类型对象
		A a = new D();
		//a.m2(); // 编译报错。A接口中没有m2()方法。
		B b = new D();
		C c = new D();


		// 调用其他接口中的方法，你需要转型（接口转型。）
        //这个编译没问题，运行也没问题。（因为a就本质就是D的一个对象，
        //D实现了A、B、C，是他们的子类,D的对象可以与A、B、C他们每个组成多态
        //所以可以接口转型）
		B b2 = (B)a;
		b2.m2();

		// 直接向下转型为D可以吗？可以
		D d = (D)a;
		d.m2();

		M m = new E();
		// 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
		// 但是一定要注意，运行时可能会出现ClassCastException异常。
		// 编译没问题，运行有问题。（m本质时E，而E只是M的实现类）
		//K k = (K)m;
		if(m instanceof K){
			K k = (K)m;
		}
	}
}

interface K{
}

interface M{
}

class E implements M{
}

// --------------------------------------------------------------------

interface X{
}
interface Y{
}
interface Z extends X,Y{ //接口和接口支持多继承。
}

//------------------------------------------------------------------

interface A{
	void m1();
}

interface B{
	void m2();
}

interface C{
	void m3();
}

// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
	// 实现A接口的m1()
	public void m1(){
		
	}
	// 实现B接口中的m2()
	public void m2(){
		System.out.println("m2 ....");
	}
	// 实现接口C中的m3()
	public void m3(){
	
	}
}

*
	继承和实现都存在的话，代码应该怎么写？
		extends 关键字在前。
		implements 关键字在后。
*/
public class Test04{
	public static void main(String[] args){
		// 创建对象（表面看Animal类没起作用！）
		Flyable f = new Cat(); //多态。
		f.fly();

		// 同一个接口
		Flyable f2 = new Pig();
		// 调用同一个fly()方法，最后的执行效果不同。
		f2.fly();

		Flyable f3 = new Fish();
		f3.fly();
	}
}

// 动物类：父类
class Animal{
}

// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
	void fly();
}

// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
	public void fly(){
		System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
	}
}

// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class Snake extends Animal{
}

// 想飞就插翅膀这个接口。
class Pig extends Animal implements Flyable{
	public void fly(){
		System.out.println("我是一只会飞的猪！！！");
	}
}

// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{ //没写extends，也是有的，默认继承Object。
	public void fly(){
		System.out.println("我是六眼飞鱼（流言蜚语）！！！");
	}
}

1.3、接口在开发中的作用

注意：接口在开发中的作用，类似于多态在开发中的作用。

       多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。
           /*
           public class Master{
               public void feed(Dog d){}
               public void feed(Cat c){}
               //假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
               //这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
           }
           */

           public class Master{
               public void feed(Animal a){
                   // 面向Animal父类编程，父类是比子类更抽象的。
                   //所以我们叫做面向抽象编程，不要面向具体编程。
                   //这样程序的扩展力就强。
               }
           }

       接口在开发中的作用？
           接口是不是完全的？是。
           而我们以后正好要求，面向抽象编程。
           面向抽象编程这句话以后可以修改为：面向接口编程。
           有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。

主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新
买一个换下来。这叫做高扩展性。（低耦合度。）

           接口在现实世界中是不是到处都是呢？
               螺栓和螺母之间有接口
               灯泡和灯口之间有接口
               笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
               接口有什么用？扩展性好。可插拔。
               接口是一个抽象的概念。

           分析：
               中午去饭馆吃饭，这个过程中有接口吗？

接口是抽象的。

菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）

谁面向接口调用。（顾客面向菜单点菜，调用接口。）

谁负责实现这个接口。（后台的厨师负责把西红柿鸡蛋做好！是接口的实现者。）

                   这个接口有什么用呢？
                       这个饭馆的“菜单”，让“顾客”和“后厨”解耦合了。
                       顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通。

           总结一句话：三个字“解耦合”
               面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
               接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

               接口可以解耦合，解开的是谁和谁的耦合！！！
               任何一个接口都有调用者和实现者。
               接口可以将调用者和实现者解耦合。
               调用者面向接口调用。
               实现者面向接口编写实现。

以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，
模块和模块之间采用接口衔接。降低耦合度。

1.4、类型和类型之间的关系：

is a（继承）、has a（关联）、like a（实现）

           is a：
               Cat is a Animal（猫是一个动物）
               凡是能够满足is a的表示“继承关系”
               A extends B

           has a：
               I has a Pen（我有一支笔）
               凡是能够满足has a关系的表示“关联关系”
               关联关系通常以“属性”的形式存在。
               A{
                   B b;
               }

           like a:
               Cooker like a FoodMenu（厨师像一个菜单一样）
               凡是能够满足like a关系的表示“实现关系”
               实现关系通常是：类实现接口。
               A implements B

   1.5、抽象类和接口有什么区别？
       在这里我们只说一下抽象类和接口在语法上的区别。
       至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

抽象类是半抽象的。
接口是完全抽象的。

抽象类中有构造方法。
接口中没有构造方法。

接口和接口之间支持多继承。
类和类之间只能单继承。

一个类可以同时实现多个接口。
一个抽象类只能继承一个类（单继承）。

       接口中只允许出现常量和抽象方法。

       这里先透露一个信息：
           以后接口使用的比抽象类多。一般抽象类使用的还是少。
           接口一般都是对“行为”的抽象。

2、package和import

   2.1、package
       第一：package出现在java源文件第一行。
       第二：带有包名怎么编译？javac -d . xxx.java
       第三：怎么运行？java 完整类名

       补充：以后说类名的时候，如果带着包名描述，表示完整类名。
       如果没有带包，描述的话，表示简类名。
           java.util.Scanner 完整类名。
           Scanner 简类名

2.2、import

       import什么时候不需要？
           java.lang不需要。
           同包下不需要。
           其它一律都需要。

       怎么用？
           import 完整类名;
           import 包名.*;

import java.util.Scanner; // 完整类名。

           // 同学的疑问：这样是不是效率比较低。
           // 这个效率不低，因为编译器在编译的时候，会自动把*变成具体的类名。
           import java.util.*;

// 想省懒劲你不能太省了。
import java.*; 这是不允许的，因为在java语言中规定，这里的*只代表某些类的名字。

iiiis310

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE进阶

day19课堂笔记1、使用集成开发工具eclipse 1.1、java的集成开发工具很多，包括：eclipse、Intellij IDEA、netbeans..... eclipse： IBM开发的。eclipse翻译为：日食。寓意吞并SUN公司（SUN是太阳。）最终没有成功，SUN公司在2009年的时候被oracle甲骨文公司收购。 eclipse在以前的开发中使用非常多，但是由于IDEA工具...
复制链接

扫一扫