IDEA 罕用快捷键
- 删除以后行, 默认是
ctrl + Y本人配置ctrl + d - 复制以后行, 本人配置
ctrl + alt + 向下光标 - 补全代码
alt + / - 增加正文和勾销正文
ctrl + / - 导入该行须要的类先配置auto import , 而后应用
alt+enter即可 - 疾速格式化代码
ctrl + alt + L - 疾速运行程序本人定义
alt + R - 生成结构器等
alt + insert[进步开发效率] - 查看一个类的层级关系
ctrl + H - 将光标放在一个办法上，输出
ctrl + B, 能够定位到办法 - 主动的调配变量名, 通过在前面加
.var
包
包的三大作用
辨别雷同名字的类
当类很多时,能够很好的治理类[看Java API文档]
管制拜访范畴
包根本语法
package com.hspedu;
阐明:
package关键字,示意打包
com.hspedu:示意包名
包的实质剖析
包的实质实际上就是创立不同的文件夹/目录来保留类文件
包的命名
命名规定
只能蕴含数字、字母、下划线、小圆点.，但不能用数字结尾，不能是关键字或保留字。
命名标准
个别是小写字母+小圆点
个别是 com.公司名.我的项目名.业务模块名
例如：
com.sina.crm.user //用户模块
com.sina.crm.order //订单模块
com.sina.crm.utils //工具类
罕用的包
一个包下,蕴含很多的类,java 中罕用的包有:
- java.lang.* //lang 包是根本包，默认引入，不须要再引入.
- java.util.* //util 包，零碎提供的工具包, 工具类，应用Scanner
- java.net.* //网络包，网络开发
- java.awt.* //是做java 的界面开发，GUI
如何引入包
语法: import 包;
咱们引入一个包的次要目标是要应用该包下的类
比方
import java.util.Scanner; //就只是引入一个类Scanner.import java.util.*;//示意将java.util包所有都引入倡议：咱们须要应用到哪个类，就导入哪个类即可，不倡议应用*导入
注意事项和应用细节
- package的作用是申明以后类所在的包，须要放在类的最下面，一个类中最多只有一句package
- import指令地位放在package的上面，在类定义后面,能够有多句且没有程序要求。
//package的作用是申明以后类所在的包，须要放在类(或者文件)的最下面，// 一个类中最多只有一句packagepackage com.hspedu.pkg;//import指令 地位放在package的上面，在类定义后面,能够有多句且没有程序要求import java.util.Scanner;import java.util.Arrays;拜访修饰符
根本介绍
java 提供四种访问控制润饰符号，用于管制办法和属性(成员变量)的拜访权限（范畴）:
- 公开级别: 用public 润饰,对外公开
- 受爱护级别: 用protected 润饰, 对子类和同一个包中的类公开
- 默认级别: 没有润饰符号,向同一个包的类公开.
- 公有级别: 用private润饰,只有类自身能够拜访,不对外公开.
拜访修饰符的拜访范畴!
应用的注意事项
- 修饰符能够用来润饰类中的属性,成员办法以及类
- 只有默认的和public能力润饰类!，并且遵循上述拜访权限的特点。
- 成员办法的拜访规定和属性齐全一样.
面向对象编程三大特色
根本介绍
面向对象编程有三大特色：封装、继承和多态。
封装介绍
封装(encapsulation)就是把形象出的数据 [属性] 和对数据的操作 [办法] 封装在一起,数据被爱护在外部,程序的其它局部只有通过被受权的操作 [办法] ,能力对数据进行操作。
封装的了解和益处
暗藏实现细节: 办法(连贯数据库) <-- 调用(传入参数)
能够对数据进行验证，保障平安正当
Person {name, age}Person p = new Person();p.name = "jack" ;p.age= 1200;封装的实现步骤(三步)
- 将属性进行私有化private【不能间接批改属性】
提供一个公共的(public)set办法，用于对属性判断并赋值
public void setXxx(类型参数名){//Xxx示意某个属性 //退出数据验证的业务逻辑 属性=参数名;}提供一个公共的
(public)get办法，用于获取属性的值public 数据类型 getXxx(){ //权限判断,Xxx某个属性 return xx;}
疾速入门案例
package com.hspedu.encap;public class Encapsulation01 { public static void main(String[] args) { //如果要应用快捷键alt+r, 须要先配置主类 //第一次，咱们应用鼠标点击模式运算程序，前面就能够用 Person person = new Person(); person.setName("韩顺平"); person.setAge(30); person.setSalary(30000); System.out.println(person.info()); System.out.println(person.getSalary()); //如果咱们本人应用结构器指定属性 Person smith = new Person("smith", 80, 50000); System.out.println("====smith的信息======"); System.out.println(smith.info()); }}/*那么在java中如何实现这种相似的管制呢?请大家看一个小程序(com.hspedu.encap: Encapsulation01.java),不能轻易查看人的年龄,工资等隐衷，并对设置的年龄进行正当的验证。年龄正当就设置，否则给默认年龄, 必须在 1-120, 年龄， 工资不能间接查看 ， name的长度在 2-6字符 之间 */class Person { public String name; //名字公开 private int age; //age 私有化 private double salary; //.. public void say(int n,String name) { } //结构器 alt+insert public Person() { } //有三个属性的结构器 public Person(String name, int age, double salary) {// this.name = name;// this.age = age;// this.salary = salary; //咱们能够将set办法写在结构器中，这样依然能够验证 setName(name); setAge(age); setSalary(salary); } // 本人写setXxx 和 getXxx 太慢，咱们应用快捷键 Generate --> Getter and Setter // 而后依据要求来欠缺咱们的代码. public String getName() { return name; } public void setName(String name) { // 退出对数据的校验,相当于减少了业务逻辑 if(name.length() >= 2 && name.length() <=6 ) { this.name = name; }else { System.out.println("名字的长度不对，须要(2-6)个字符，默认名字"); this.name = "无名人"; } } public int getAge() { return age; } public void setAge(int age) { //判断 if(age >= 1 && age <= 120) {//如果是正当范畴 this.age = age; } else { System.out.println("你设置年龄不对，须要在 (1-120), 给默认年龄18 "); this.age = 18;//给一个默认年龄 } } public double getSalary() { //能够这里减少对以后对象的权限判断 return salary; } public void setSalary(double salary) { this.salary = salary; } //写一个办法，返回属性信息 public String info() { return "信息为 name=" + name + " age=" + age + " 薪水=" + salary; }}将结构器和setXxx 联合
能够将set办法写在结构器中，这样能够保障验证。
public Person(String name, int age, double salary) { // this.name = name; // this.age = age; // this.salary = salary; //咱们能够将set 办法写在结构器中，这样依然能够验证 setName(name); setAge(age); setSalary(salary);}面向对象编程-继承
继承能够解决代码复用,让咱们的编程更加凑近人类思维.当多个类存在雷同的属性(变量)和办法时,能够从这些类中形象出父类,在父类中定义这些雷同的属性和办法，所有的子类不须要从新定义这些属性和办法，只须要通过extends 来申明继承父类即可。
继承的根本语法
class 子类 extends 父类 {}1)子类就会主动领有父类定义的属性和办法
2)父类又叫超类,基类。
3)子类又叫派生类。
继承的深刻探讨/细节问题
- 子类继承了所有的属性和办法，非公有的属性和办法能够在子类间接拜访, 然而公有属性和办法不能在子类间接拜访，要通过父类提供公共的办法去拜访
- 子类必须调用父类的结构器，实现父类的初始化。先调用父类结构器，再调用子类结构器。
- 当创立子类对象时，不论应用子类的哪个结构器，默认状况下总会去调用父类的无参结构器，如果父类没有提供无参结构器，则必须在子类的结构器中用super 去指定应用父类的哪个结构器实现对父类的初始化工作，否则，编译不会通过.
- 如果心愿指定去调用父类的某个结构器，则显式的调用一下:
super(参数列表) - super 在应用时，必须放在结构器第一行( super 只能在结构器中应用 )
- super() 和this() 都只能放在结构器第一行，因而这两个办法不能共存在一个结构器。
- java 所有类都是Object 类的子类, Object 是所有类的基类.
- 父类结构器的调用不限于间接父类！将始终往上追溯直到Object 类(顶级父类)
- 子类最多只能继承一个父类(指间接继承)，即java中是单继承机制。
思考：如何让A 类继承B类和C类？ 办法：A 继承B， B 继承C。 - 不能滥用继承，子类和父类之间必须满足is-a 的逻辑关系
package com.hspedu.extend_;import java.util.Arrays;//输出ctrl + H 能够看到类的继承关系public class Sub extends Base { //子类 public Sub(String name, int age) { //1. 要调用父类的无参结构器, 如下或者什么都不写,默认就是调用super() //super();//父类的无参结构器 //2. 要调用父类的 Base(String name) 结构器 //super("hsp"); //3. 要调用父类的 Base(String name, int age) 结构器 super("king", 20); //细节：super在应用时，必须放在结构器第一行 //细节: super() 和 this() 都只能放在结构器第一行，因而这两个办法不能共存在一个结构器 //this() 不能再应用了 System.out.println("子类Sub(String name, int age)结构器被调用...."); } public Sub() {//无参结构器 //super(); //默认调用父类的无参结构器 super("smith", 10); System.out.println("子类Sub()结构器被调用...."); } //当创立子类对象时，不论应用子类的哪个结构器，默认状况下总会去调用父类的无参结构器 public Sub(String name) { super("tom", 30); //do nothing... System.out.println("子类Sub(String name)结构器被调用...."); } public void sayOk() {//子类办法 //非公有的属性和办法能够在子类间接拜访 //然而公有属性和办法不能在子类间接拜访 System.out.println(n1 + " " + n2 + " " + n3); test100(); test200(); test300(); //test400();谬误 //要通过父类提供公共的办法去拜访 System.out.println("n4=" + getN4()); callTest400();// }}继承的实质剖析!
咱们着一个案例来剖析当子类继承父类，创立子类对象时，内存中到底产生了什么?
当子类对象创立好后，建设查找的关系
- 最先加载父类，别离是Object类，而后加载Grandpa，再Father，最初Son。
- 而后再调配堆空间：不同类的雷同变量名不会抵触，堆中空间不同。
- 最初Son对象（0x11都是）返回给main中的援用。
那么最初输入什么呢？（还是就近准则）
package com.hspedu.extend_;/** * 解说继承的实质 */public class ExtendsTheory { public static void main(String[] args) { Son son = new Son();//内存的布局 //?-> 这时请大家留神，要依照查找关系来返回信息 //(1) 首先看子类是否有该属性 //(2) 如果子类有这个属性，并且能够拜访，则返回信息 //(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且能够拜访，就返回信息..) //(4) 如果父类没有就依照(3)的规定，持续找下级父类，直到Object... System.out.println(son.name);//返回就是大头儿子 //System.out.println(son.age);//返回的就是39 //System.out.println(son.getAge());//返回的就是39 System.out.println(son.hobby);//返回的就是游览 }}class GrandPa { //爷类 String name = "大头爷爷"; String hobby = "游览";}class Father extends GrandPa {//父类 String name = "大头爸爸"; private int age = 39; public int getAge() { return age; }}class Son extends Father { //子类 String name = "大头儿子";}super 关键字
根本介绍
super 代表父类的援用，用于拜访父类的属性、办法、结构器
根本语法
1.拜访父类的属性，但不能拜访父类的private属性[案例]
super.属性名;2.拜访父类的办法,不能拜访父类的private办法
super.办法名(参数列表);3.拜访父类的结构器:
super(参数列表);只能放在结构器的第一句，只能呈现一句!package com.hspedu.super_;public class A extends Base{ //4个属性 //public int n1 = 100; protected int n2 = 200; int 3 = 300; private int n4 = 400; public A() {} public A(String name) {} public A(String name, int age) {}// public void cal() {// System.out.println("A类的cal() 办法...");// } public void test100() { } protected void test200() { } void test300() { } private void test400() { }}cal() 和 this.cal() 雷同，就近准则。
super.cal() 的程序是间接查找父类，其余的规定一样
package com.hspedu.super_;public class B extends A { public int n1 = 888; //编写测试方法 public void test() { //super的拜访不限于间接父类，如果爷爷类和本类中有同名的成员，也能够应用super去拜访爷爷类的成员； // 如果多个基类(下级类)中都有同名的成员，应用super拜访遵循就近准则。A->B->C System.out.println("super.n1=" + super.n1); super.cal(); } //拜访父类的属性 , 但不能拜访父类的private属性 [案例]super.属性名 public void hi() { System.out.println(super.n1 + " " + super.n2 + " " + super.n3 ); } public void cal() { System.out.println("B类的cal() 办法..."); } public void sum() { System.out.println("B类的sum()"); //心愿调用父类-A 的cal办法 //这时，因为子类B没有cal办法，因而我能够应用上面三种形式 // !找cal办法时(cal() 和 this.cal())，程序是: // (1)先找本类，如果有，则调用 // (2)如果没有，则找父类(如果有，并能够调用，则调用) // (3)如果父类没有，则持续找父类的父类,整个规定，就是一样的,直到 Object类 // 提醒：如果查找办法的过程中，找到了，然而不能拜访， 则报错, cannot access // 如果查找办法的过程中，没有找到，则提醒办法不存在 //cal(); this.cal(); //等价 cal // !找cal办法(super.call()) 的程序是间接查找父类，其余的规定一样 //super.cal(); //演示拜访属性的规定 // !n1 和 this.n1 查找的规定是 //(1) 先找本类，如果有，则调用 //(2) 如果没有，则找父类(如果有，并能够调用，则调用) //(3) 如果父类没有，则持续找父类的父类,整个规定，就是一样的,直到 Object类 // 提醒：如果查找属性的过程中，找到了，然而不能拜访， 则报错, cannot access // 如果查找属性的过程中，没有找到，则提醒属性不存在 System.out.println(n1); System.out.println(this.n1); // !找n1 (super.n1) 的程序是间接查找父类属性，其余的规定一样 System.out.println(super.n1); } //拜访父类的办法，不能拜访父类的private办法 super.办法名(参数列表); public void ok() { super.test100(); super.test200(); super.test300(); //super.test400();//不能拜访父类private办法 } //拜访父类的结构器(这点后面用过)：super(参数列表);只能放在结构器的第一句，只能呈现一句！ public B() { //super(); //super("jack", 10); super("jack"); }}super 给编程带来的便当/细节
- 调用父类的结构器的益处(分工明确,父类属性由父类初始化，子类的属性由子
类初始化) - 当子类中有和父类中的成员(属性和办法)重名时，为了拜访父类的成员，必须
通过super。如果没有重名，应用super、this、间接拜访是一样的成果! - super的拜访不限于间接父类，如果爷爷类和本类中有同名的成员，也能够应用
super去拜访爷爷类的成员; 如果多个基类(下级类)中都有同名的成员，应用super拜访遵循就近准则。A->B->C，当然也须要恪守拜访权限的相干规定
super 和this 的比拟
办法重写/笼罩(override)
简略的说:办法笼罩(重写)就是子类有一个办法, 和父类的某个办法的名称、返回类型、参数一样,那么咱们就说子类的这个办法笼罩了父类的办法。
注意事项和应用细节
办法重写也叫办法笼罩，须要满足上面的条件
- 子类的办法的形参列表,办法名称,要和父类办法的形参列表办法名称齐全一样。
子类办法的返回类型和父类办法返回类型一样，或者是父类返回类型的子类
比方交类返回类型是Object,子类办法返回类型是String
public object getInfo()
public String getInfo()子类办法不能放大父类办法的拜访权限。最好大于等于父类的权限。
public > protected > 默认>private
重写和重载比拟!
面向对象编程-多态
传统的办法带来的问题是什么?
代码的复用性不高，而且不利于代码保护
解决方案： 引出咱们要解说的多态
多[多种]态[状态]根本介绍
办法或对象具备多种状态。是面向对象的第三大特色，多态是建设在封装和继承根底之上的。
多态的具体体现
办法的多态
重写和重载就体现多态
对象的多态!
(1) 一个对象的编译类型和运行类型能够不统一
(2) 编译类型在定义对象时，就确定了，不能扭转
(3) 运行类型是能够变动的.
(4) 编译类型看定义时 = 号的右边，运行类型看 = 号的左边
Animal animal = new Dog() // animal编译类型是Animal，运行类型Doganimal = new Cat();// animal的运行类型变成了Cat,编译类型依然是 Animal多态注意事项和细节探讨
多态的前提是：两个对象(类)存在继承关系
多态的向上转型
- 实质:父类的援用指向了子类的对象
- 语法:
父类类型援用名=new子类类型(); 特点:编译类型看右边,运行类型看左边。
**能够调用父类中的所有成员(需恪守拜访权限),不能调用子类中特有成员;
最终运行成果看子类的具体实现!** （运行时看运行类型，例如找办法时就是采纳就近准则）因为在编译阶段，能调用哪些成员，是由编译类型决定的。
多态向下转型
语法: 子类类型 援用名 = (子类类型) 父类援用;
- 只能强转父类的援用，不能强转父类的对象
- 要求父类的援用必须指向的是以后指标类型的对象
- 当向下转型后，能够调用子类类型中所有的成员
package com.hspedu.poly_.detail_;public class PolyDetail { public static void main(String[] args) { //向上转型: 父类的援用指向了子类的对象 //语法：父类类型援用名 = new 子类类型(); Animal animal = new Cat(); Object obj = new Cat();//能够吗? 能够 Object 也是 Cat的父类 //向上转型调用办法的规定如下: //(1)能够调用父类中的所有成员(需恪守拜访权限) //(2)然而不能调用子类的特有的成员 //(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的 //animal.catchMouse();谬误 //(4)最终运行成果看子类(运行类型)的具体实现, 即调用办法时，依照从子类(运行类型)开始查找办法 //，而后调用，规定我后面咱们讲的办法调用规定统一。 animal.eat();//猫吃鱼.. animal.run();//跑 animal.show();//hello,你好 animal.sleep();//睡 //老师心愿，能够调用Cat的 catchMouse办法 //多态的向下转型 //(1)语法：子类类型 援用名 =（子类类型）父类援用; //问一个问题? cat 的编译类型 Cat,运行类型是 Cat Cat cat = (Cat) animal; cat.catchMouse();//猫抓老鼠 //(2)要求父类的援用必须指向的是以后指标类型的对象 // animal 原本创立时就指向 cat对象 // 前面 animal 向下转型 cat 指向 cat对象 Dog dog = (Dog) animal;//能够吗？ 谬误! System.out.println("ok~~"); }}属性没有重写之说
属性没有重写之说！属性的值看编译类型
package com.hspedu.poly_.detail_;public class PolyDetail02 { public static void main(String[] args) { //属性没有重写之说！属性的值看编译类型 Base base = new Sub();//向上转型 System.out.println(base.count);// ？ 看编译类型 10 Sub sub = new Sub(); System.out.println(sub.count);//? 20 }}class Base { //父类 int count = 10;//属性}class Sub extends Base {//子类 int count = 20;//属性}instanceOf 比拟操作符
用于判断对象的 运行类型 是否为 XX 类型 或 XX 类型的子类型
package com.hspedu.poly_.detail_;public class PolyDetail03 { public static void main(String[] args) { BB bb = new BB(); System.out.println(bb instanceof BB);// true System.out.println(bb instanceof AA);// true //aa 编译类型 AA, 运行类型是BB //BB是AA子类 AA aa = new BB(); System.out.println(aa instanceof AA); // true System.out.println(aa instanceof BB); // true Object obj = new Object(); System.out.println(obj instanceof AA);//false String str = "hello"; //System.out.println(str instanceof AA); System.out.println(str instanceof Object);//true }}class AA {} //父类class BB extends AA {}//子类java 的动静绑定机制!!
**1.当调用对象办法的时候，该办法会和该对象的内存地址/运行类型绑定
2.当调用对象属性时，没有动静绑定机制，哪里申明，哪里应用**，找不到再去父类中寻找。
package com.hspedu.poly_.dynamic_;public class DynamicBinding { public static void main(String[] args) { //a 的编译类型 A, 运行类型 B A a = new B();//向上转型 System.out.println(a.sum()); //?40 -> 30 (20 + 10) System.out.println(a.sum1());//?30 -> 20 (10 + 10) }}class A {//父类 public int i = 10; //动静绑定机制: public int sum() {//父类sum() return getI() + 10;//20 + 10 } public int sum1() {//父类sum1() return i + 10;//10 + 10 } public int getI() {//父类getI return i; }}class B extends A {//子类 public int i = 20;// public int sum() {// return i + 20;// } public int getI() {//子类getI() return i; }// public int sum1() {// return i + 10;// }}多态的利用
多态数组
数组的定义类型为父类类型，外面保留的理论元素类型为子类类型。
利用实例:现有一个继承构造如下：要求创立1 个Person 对象、2 个Student 对象和2 个Teacher 对象, 对立放在数组中，并调用每个对象 say 办法.
利用实例降级：如何调用子类特有的办法，比方Teacher 有一个teach , Student 有一个study ，怎么调用？
package com.hspedu.poly_.polyarr_;public class PloyArray { public static void main(String[] args) { //利用实例:现有一个继承构造如下：要求创立1个Person对象、 // 2个Student 对象和2个Teacher对象, 对立放在数组中，并调用每个对象say办法 Person[] persons = new Person[5]; persons[0] = new Person("jack", 20); persons[1] = new Student("mary", 18, 100); persons[2] = new Student("smith", 19, 30.1); persons[3] = new Teacher("scott", 30, 20000); persons[4] = new Teacher("king", 50, 25000); //循环遍历多态数组，调用say for (int i = 0; i < persons.length; i++) { //老师提醒: person[i] 编译类型是 Person ,运行类型是是依据理论状况有JVM来判断 System.out.println(persons[i].say());//动静绑定机制 // 这里聪慧. 应用 类型判断 + 向下转型.!!!! if(persons[i] instanceof Student) {//判断person[i] 的运行类型是不是Student Student student = (Student)persons[i];//向下转型 student.study(); //小伙伴也能够应用一条语句 ((Student)persons[i]).study(); } else if(persons[i] instanceof Teacher) { Teacher teacher = (Teacher)persons[i]; teacher.teach(); } else if(persons[i] instanceof Person){ //System.out.println("你的类型有误, 请本人查看..."); } else { System.out.println("你的类型有误, 请本人查看..."); } } }}多态参数
办法定义的形参类型为父类类型，实参类型容许为子类类型利用实例
定义员工类Employee，蕴含姓名和月工资[private]，以及计算年工资getAnnual的办法。普通员工和经理继承了员工，经理类多了奖金bonus属性和治理manage办法，普通员工类多了work办法，普通员工和经理类要求别离重写getAnnual办法
测试类中增加一个办法showEmpAnnual(Employee e)，实现获取任何员工对象的年工资,并在main办法中调用该办法[e.getAnnual()]
测试类中增加一个办法，testWork,如果是普通员工，则调用work办法，如果是经理,则调用manage办法
package com.hspedu.poly_.polyarr_;public class Person {//父类 private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String say() {//返回名字和年龄 return name + "\t" + age; }}package com.hspedu.poly_.polyarr_;public class Student extends Person { private double score; public Student(String name, int age, double score) { super(name, age); this.score = score; } public double getScore() { return score; } public void setScore(double score) { this.score = score; } //重写父类say @Override public String say() { return "学生 " + super.say() + " score=" + score; } //特有的办法 public void study() { System.out.println("学生 " + getName() + " 正在学java..."); }}package com.hspedu.poly_.polyarr_;public class Teacher extends Person { private double salary; public Teacher(String name, int age, double salary) { super(name, age); this.salary = salary; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } //写重写父类的say办法 @Override public String say() { return "老师 " + super.say() + " salary=" + salary; } //特有办法 public void teach() { System.out.println("老师 " + getName() + " 正在讲java课程..."); }}package com.hspedu.poly_.polyarr_;public class PloyArray { public static void main(String[] args) { //利用实例:现有一个继承构造如下：要求创立1个Person对象、 // 2个Student 对象和2个Teacher对象, 对立放在数组中，并调用每个对象say办法 Person[] persons = new Person[5]; persons[0] = new Person("jack", 20); persons[1] = new Student("mary", 18, 100); persons[2] = new Student("smith", 19, 30.1); persons[3] = new Teacher("scott", 30, 20000); persons[4] = new Teacher("king", 50, 25000); //循环遍历多态数组，调用say for (int i = 0; i < persons.length; i++) { //老师提醒: person[i] 编译类型是 Person ,运行类型是是依据理论状况有JVM来判断 System.out.println(persons[i].say());//动静绑定机制 //这里大家聪慧. 应用 类型判断 + 向下转型. if(persons[i] instanceof Student) {//判断person[i] 的运行类型是不是Student Student student = (Student)persons[i];//向下转型 student.study(); //小伙伴也能够应用一条语句 ((Student)persons[i]).study(); } else if(persons[i] instanceof Teacher) { Teacher teacher = (Teacher)persons[i]; teacher.teach(); } else if(persons[i] instanceof Person){ //System.out.println("你的类型有误, 请本人查看..."); } else { System.out.println("你的类型有误, 请本人查看..."); } } }}Object 类详解
equals 办法
==和equals 的比照!!!!!
==是一个比拟运算符
==:既能够判断根本类型，又能够判断援用类型
- ==:如果判断根本类型，判断的是值是否相等。示例: int i=10; double d=10.0;
- ==:如果判断援用类型，判断的是地址是否相等，即断定是不是同一个对象
equals:是Object类中的办法，只能判断援用类型，看Jdk源码。（办法：光标放在办法上。而后按 ctrl + B 进行查看源码）
- 默认判断的是地址是否相等，子类中往往重写该办法，用于判断内容是否相等。比方 Integer,String【看看String和 Integer的equals源代码】
package com.hspedu.object_;public class Equals01 { public static void main(String[] args) { A a = new A(); A b = a; A c = b; System.out.println(a == c);//true System.out.println(b == c);//true // 编译类型是B，然而实质上还是一个地址指向a B bObj = a; System.out.println(bObj == c);//true int num1 = 10; double num2 = 10.0; System.out.println(num1 == num2);// 根本数据类型，判断值是否相等 //equals 办法，源码怎么查看. //把光标放在equals办法，间接输出ctrl+b //如果你应用不了. 本人配置. 即可应用. /* //带大家看看Jdk的源码 String类的 equals办法 //把Object的equals办法重写了,变成了比拟两个字符串值是否雷同 public boolean equals(Object anObject) { if (this == anObject) {//如果是同一个对象 return true;//返回true } if (anObject instanceof String) {//判断类型 String anotherString = (String)anObject;//向下转型 int n = value.length; if (n == anotherString.value.length) {//如果长度雷同 char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) {//而后一个一个的比拟字符 if (v1[i] != v2[i]) return false; i++; } return true;//如果两个字符串的所有字符都相等，则返回true } } return false;//如果比拟的不是字符串，则间接返回false } */ "hello".equals("abc"); //看看Object类的 equals 是 /* //即Object 的equals 办法默认就是比拟对象地址是否雷同 //也就是判断两个对象是不是同一个对象. public boolean equals(Object obj) { return (this == obj); } */ /* //从源码能够看到 Integer 也重写了Object的equals办法, //变成了判断两个值是否雷同 public boolean equals(Object obj) { if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false; } */ Integer integer1 = new Integer(1000); Integer integer2 = new Integer(1000); System.out.println(integer1 == integer2);//false System.out.println(integer1.equals(integer2));//true String str1 = new String("hspedu"); String str2 = new String("hspedu"); System.out.println(str1 == str2);//false System.out.println(str1.equals(str2));//true }}class B {}class A extends B {}如何重写 equals 办法
利用实例: 判断两个Person 对象的内容是否相等，如果两个Person 对象的各个属性值都一样，则返回true，反之false。
查看：com.hspedu.object_ EqualsExercise01
hashCode 办法
public int hashCode()
返回该对象的哈希码值。反对此办法是为了进步哈希表（例如java.util.Hashtable 提供的哈希表）的性能。
hashCode 的惯例协定是：
- 在 Java 应用程序执行期间，在对同一对象屡次调用 hashCode 办法时，必须统一地返回雷同的整数，前提是将对象进行 equals 比拟时所用的信息没有被批改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
- 如果依据 equals(Object) 办法，两个对象是相等的，那么对这两个对象中的每个对象调用
hashCode办法都必须生成雷同的整数后果。 - 如果依据
equals(java.lang.Object))
办法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 办法不
要求肯定生成不同的整数后果。然而，程序员应该意识到，为不相等的对象生成不同整数后果能够进步哈希表的性能。
实际上，由 Object 类定义的 hashCode
办法的确会针对不同的对象返回不同的整数。（这个别是通过将该对象的外部地址转换成一个整数来实现的，然而 JavaTM 编程语言不须要这种实现技巧。）
返回：
此对象的一个哈希码值。
另请参见：
[equals(java.lang.Object)], [Hashtable]
总结
- 进步具备哈希构造的容器的效率！
- 两个援用，如果指向的是同一个对象，则哈希值必定是一样的！
- 两个援用，如果指向的是不同对象，则哈希值是不一样的（当然也可能存在碰撞）
- 哈希值次要依据地址号来的！ 不能齐全将哈希值等价于地址。（java跑在JVM上，无奈真正拿到其外部地址）。
- 前面在汇合，中hashCode 如果需要的话，也会重写, 在解说汇合时，具体看如何重写hashCode()代码。
toString 办法
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }- 根本介绍
默认返回：全类名+@+哈希值的十六进制，子类往往重写toString 办法，用于返回对象的属性信息（全类名就是包名 + 类名） - 重写toString 办法，打印对象或拼接对象时，都会主动调用该对象的toString 模式.
- 当间接输入一个对象时， toString 办法会被默认的调用, 比方System.out.println(monster) ；// 就会默认调用monster.toString()
finalize 办法
- 当对象被回收时，零碎主动调用该对象的finalize 办法。子类能够重写该办法，做一些开释资源（数据库的连贯，关上或者敞开文件）的操作。
- 什么时候被回收：当某个对象没有任何援用时，则jvm 就认为这个对象是一个垃圾对象，就会应用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize 办法。（当然并不是一有垃圾就立马回收，有对应的垃圾回收GC算法）。
- 垃圾回收机制的调用，是由零碎来决定(即有本人的GC算法), 也能够通过System.gc() 被动触发垃圾回收机制。
- 咱们在理论开发中，简直不会使用finalize , 所以更多就是为了应酬面试。
package com.hspedu.object_;//演示 Finalize的用法public class Finalize_ { public static void main(String[] args) { Car bmw = new Car("宝马"); //这时 car对象就是一个垃圾,垃圾回收器就会回收(销毁)对象, 在销毁对象前，会调用该对象的finalize办法 //,程序员就能够在 finalize中，写本人的业务逻辑代码(比方开释资源：数据库连贯,或者关上文件..) //,如果程序员不重写 finalize,那么就会调用 Object类的 finalize, 即默认解决 //,如果程序员重写了 finalize, 就能够实现本人的逻辑 bmw = null; System.gc();//被动调用垃圾回收器 System.out.println("程序退出了...."); }}class Car { private String name; //属性, 资源。。 public Car(String name) { this.name = name; } //重写finalize @Override protected void finalize() throws Throwable { System.out.println("咱们销毁 汽车" + name ); System.out.println("开释了某些资源..."); }}断点调试(debug)
在断点调试过程中，是运行状态，是以对象的运行类型来执行的.
A extends B; Bb = new A(); b.xx();
断点调试介绍
断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，而后你能够一步一步往下调试，调试过程中能够看各个变量以后的值，出错的话，调试到出错的代码行即显示谬误，停下。进行剖析从而找到这个Bug。
断点调试也能帮忙咱们查看java底层源代码的执行过程。
断点调试的快捷键
F7(跳入) F8(跳过) shift+F8(跳出) F9(resume,执行到下一个断点)
F7：跳入办法内
F8: 逐行执行代码.
shift+F8: 跳出办法
Idea debug进入 Jdk源码
办法1：
应用force step into : 快捷键 alt + shift + F7
办法2：
这个配置一下就好了：点击Setting --> Build,Execution,Deployment --> Debugger --> Stepping 把Do not step into the classes中的java.，javax.勾销勾选。
断点能够在debug 过程中，动静的下断点。（看简单逻辑时罕用）
我的项目-零钱通
package com.hspedu.smallchange;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Scanner;public class SmallChangeSys { //化繁为简 //1. 先实现显示菜单，并能够抉择菜单，给出对应提醒 //2. 实现零钱透明细 //3. 实现收益入账 //4. 生产 //5. 退出 //6. 用户输出4退出时，给出提醒"你确定要退出吗? y/n"，必须输出正确的y/n ，否则循环输出指令，直到输出y 或者 n //7. 在收益入账和生产时，判断金额是否正当，并给出相应的提醒 public static void main(String[] args) { //定义相干的变量 boolean loop = true; Scanner scanner = new Scanner(System.in); String key = ""; //2. 实现零钱透明细 //老韩思路, (1) 能够把收益入账和生产，保留到数组 (2) 能够应用对象 (3) 简略的话能够应用String拼接 String details = "-----------------零钱透明细------------------"; //3. 实现收益入账 实现性能驱动程序员减少新的变动和代码 //老韩思路, 定义新的变量 double money = 0; double balance = 0; Date date = null; // date 是 java.util.Date 类型，示意日期 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); //能够用于日期格式化的 //4. 生产 //定义新变量，保留生产的起因 String note = ""; do { System.out.println("\n================零钱通菜单==============="); System.out.println("\t\t\t1 零钱透明细"); System.out.println("\t\t\t2 收益入账"); System.out.println("\t\t\t3 生产"); System.out.println("\t\t\t4 退 出"); System.out.print("请抉择(1-4): "); key = scanner.next(); //应用switch 分支管制 switch (key) { case "1": System.out.println(details); break; case "2": System.out.print("收益入账金额:"); money = scanner.nextDouble(); //money 的值范畴应该校验 -》 一会在欠缺 //老师思路, 编程思维 //找出不正确的金额条件，而后给出提醒, 就间接break if(money <= 0) { System.out.println("收益入账金额 须要 大于 0"); break; } //找出正确金额的条件 balance += money; //拼接收益入账信息到 details date = new Date(); //获取以后日期 details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" + balance; break; case "3": System.out.print("生产金额:"); money = scanner.nextDouble(); //money 的值范畴应该校验 -》 一会在欠缺 //找出金额不正确的状况 //过关斩将 校验形式. if(money <= 0 || money > balance) { System.out.println("你的生产金额 应该在 0-" + balance); break; } System.out.print("生产阐明:"); note = scanner.next(); balance -= money; //拼接生产信息到 details date = new Date(); //获取以后日期 details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance; break; case "4": //用户输出4退出时，给出提醒"你确定要退出吗? y/n"，必须输出正确的y/n ， // 否则循环输出指令，直到输出y 或者 n // 老韩思路剖析 // (1) 定义一个变量 choice, 接管用户的输出 // (2) 应用 while + break, 来解决接管到的输出时 y 或者 n // (3) 退出while后，再判断choice是y还是n ,就能够决定是否退出 // (4) 倡议一段代码，实现一个小性能，尽量不要混在一起 String choice = ""; while (true) { //要求用户必须输出y/n ,否则就始终循环 System.out.println("你确定要退出吗? y/n"); choice = scanner.next(); if ("y".equals(choice) || "n".equals(choice)) { break; } //第二个计划// if("y".equals(choice)) {// loop = false;// break;// } else if ("n".equals(choice)) {// break;// } } //当用户退出while ,进行判断 if (choice.equals("y")) { loop = false; } break; default: System.out.println("抉择有误，请从新抉择"); } } while (loop); System.out.println("-----退出了零钱通我的项目-----"); }}改成OOP 版本，领会OOP 编程带来的益处
package com.hspedu.smallchange.oop;/** * 这里咱们间接调用SmallChangeSysOOP 对象，显示主菜单即可 */public class SmallChangeSysApp { public static void main(String[] args) { System.out.println("====hello公司===="); new SmallChangeSysOOP().mainMenu(); }}package com.hspedu.smallchange.oop;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Scanner;/** * 该类是实现零钱通的各个性能的类 * 应用OOP(面向对象编程) * 将各个性能对应一个办法. */public class SmallChangeSysOOP { //属性.. //定义相干的变量 boolean loop = true; Scanner scanner = new Scanner(System.in); String key = ""; //2. 实现零钱透明细 //老韩思路, (1) 能够把收益入账和生产，保留到数组 (2) 能够应用对象 (3) 简略的话能够应用String拼接 String details = "-----------------零钱透明细------------------"; //3. 实现收益入账 实现性能驱动程序员减少新的变动和代码 //老韩思路, 定义新的变量 double money = 0; double balance = 0; Date date = null; // date 是 java.util.Date 类型，示意日期 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); //能够用于日期格式化的 //4. 生产 //定义新变量，保留生产的起因 String note = ""; //先实现显示菜单，并能够抉择 public void mainMenu() { do { System.out.println("\n================零钱通菜单(OOP)==============="); System.out.println("\t\t\t1 零钱透明细"); System.out.println("\t\t\t2 收益入账"); System.out.println("\t\t\t3 生产"); System.out.println("\t\t\t4 退 出"); System.out.print("请抉择(1-4): "); key = scanner.next(); //应用switch 分支管制 switch (key) { case "1": this.detail(); break; case "2": this.income(); break; case "3": this.pay(); break; case "4": this.exit(); break; default: System.out.println("抉择有误，请从新抉择"); } } while (loop); } //实现零钱透明细 public void detail() { System.out.println(details); } //实现收益入账 public void income() { System.out.print("收益入账金额:"); money = scanner.nextDouble(); //money 的值范畴应该校验 -》 一会在欠缺 //老师思路, 编程思维 //找出不正确的金额条件，而后给出提醒, 就间接return if(money <= 0) { System.out.println("收益入账金额 须要 大于 0"); return; //退出办法，不在执行前面的代码。 } //找出正确金额的条件 balance += money; //拼接收益入账信息到 details date = new Date(); //获取以后日期 details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" + balance; } //生产 public void pay() { System.out.print("生产金额:"); money = scanner.nextDouble(); //money 的值范畴应该校验 -》 一会在欠缺 //找出金额不正确的状况 //过关斩将 校验形式. if(money <= 0 || money > balance) { System.out.println("你的生产金额 应该在 0-" + balance); return; } System.out.print("生产阐明:"); note = scanner.next(); balance -= money; //拼接生产信息到 details date = new Date(); //获取以后日期 details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance; } //退出 public void exit() { //用户输出4退出时，给出提醒"你确定要退出吗? y/n"，必须输出正确的y/n ， // 否则循环输出指令，直到输出y 或者 n // 老韩思路剖析 // (1) 定义一个变量 choice, 接管用户的输出 // (2) 应用 while + break, 来解决接管到的输出时 y 或者 n // (3) 退出while后，再判断choice是y还是n ,就能够决定是否退出 // (4) 倡议一段代码，实现一个小性能，尽量不要混在一起 String choice = ""; while (true) { //要求用户必须输出y/n ,否则就始终循环 System.out.println("你确定要退出吗? y/n"); choice = scanner.next(); if ("y".equals(choice) || "n".equals(choice)) { break; } //第二个计划// if("y".equals(choice)) {// loop = false;// break;// } else if ("n".equals(choice)) {// break;// } } //当用户退出while ,进行判断 if (choice.equals("y")) { loop = false; } }}文章和代码曾经归档至【Github仓库：https://github.com/timerring/java-tutorial 】或者公众号【AIShareLab】回复 java 也可获取。