Java面向对象编程(中级部分)
目录
- IDE(集成开发环境) - IDEA
- IDEA 的使用技巧和经验
- 包
- 基本介绍
- 包的本质分析(原理)
- 包的命名规则和命名规范
- 命名规则
- 命名规范
- 常用的包
- 注意事项和使用细节
- 访问修饰符
- 基本介绍
- 4中访问修饰符的访问范围
- 使用的注意事项
- 面向对象编程三大特征
- 封装
- 基本介绍
- 封装的理解和好处
- 封装的实现步骤(三步)
- 案例入门
- 代码
- 快捷键快速生成 setXxx 和 getXxx
- 年龄超出的情况
- 名字长度不对的情况
- 将构造器和 setXxx结合
- 解决
- 练习题
- 继承
- 引入
- 基本介绍和示意图
- 继承的基本语法
- 继承给编程带来的便利
- 案例入门
- 代码
- 继承的深入讨论/细节问题(重要)
- 继承的本质分析(重要)
- super关键字
- 基本介绍
- super给变成带来的便利/细节
- super和this的比较
- 方法重写/覆盖(override)
- 基本介绍
- 注意事项和使用细节
- 方法重写和重载的比较
- 多态
- 引入
- 多[多种]态[状态]基本介绍
- 多态的具体体现
- 对象的多态(重点)
- 多态快速入门案例
- 多态注意事项和细节讨论
- Java的动态内存绑定机制(重要)
- 多态的应用
- 多态数组
- 应用实例
- 多态参数
- 应用实例
- Object类详解
- equals方法
- == 和 equals 的对比(面试题)
- 如何重写equals方法
- hashCode方法
- toString方法
- finalize方法(实际开发基本不用,应付面试)
- 断点调试(Debug)
- 引入+基本介绍
- 断点调试的快捷键
IDE(集成开发环境) - IDEA
IDEA 的使用技巧和经验
- 设置字体 和 颜色主题
- 字符编码设置
- 在我们使用IDEA的时候,src文件夹里面存放的是源码文件.java, out文件夹里面存放的是编码后的文件.class
IDEA常用快捷键 - 都可以自己配置
删除当前行,默认是 ctrl + Y
复制当前行,默认是 ctrl + D
不全代码:alt + /
添加注释和取消注释:ctrl + /
- 第一次是添加注释
- 第二次是取消注释
导入该行需要的类,先配置 auto import,然后使用 alt + enter即可
快速格式化代码:ctrl + alt + L
快速运行程序:shift + F10
生成构造器等:alt + insert [提高开发效率]
查看一个类的层级关系:ctrl + H [继承一块]
将光标放在一个方法商,输入 ctrl + B,可以定义到方法
自动的分配变量名,在后面加.var
- 模板/自定义模板
包
基本介绍
- 引入
现在有两个程序员共同开发一个java项目,项目员xiaoming希望定义一个类取名Dog,程序员xiaoqiang也想定义一个类也叫Dog,这下那该怎么办
- 包的三大作用
- 区分相同名字的类
- 当类很多时,可以很好的管理类:如Java API文档
- 控制访问范围
- 包的基本语法
package com.zanedu
解读:
- package 关键字,表示打包
- com.zanedu,表示包名
包的本质分析(原理)
- 包的本质实际上就是创建不同的文件夹/目录来保存类文件
包的命名规则和命名规范
命名规则
- 只能包含数组、字母、下划线、小圆点.,但不能用数字开头,也不能是关键字或保留字
demo.class.exec1 //error class是关键字
demo.12a //error 12a是数字开头
demo.ab12.oa //ok
命名规范
- 一般是小写字母 + 小圆点
- 一般是 com.公司名.项目名.业务模块名
如:com.zanedu.oa.model; com.zanedu.oa.controller;
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 的作用是声明当前类所在的包,需要放在类(或者文件)的最上面,
//一个类中最多只有一句 package
package com.zanedu.pkg;//import 指令 位置放在 package 的下面,在类定义前面,可以有多句且没有顺序要求
import java.util.Arrays;
import java.util.Scanner;//类定义
public class PkgDetail {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int[] arr = {0, -1, 1};Arrays.sort(args);}
}
访问修饰符
基本介绍
- java提供四种访问控制修饰符号,用于控制方法和属性(成员变量)的访问权限(范围):
- 公开级别:用public修饰,对外开发
- 受保护级别:用protected修饰,对子类和同一个包中的类公开
- 默认级别:没有修饰符号,向同一个包的类公开
- 私有级别:用private修饰,只有类本身可以访问,不对外开放
4中访问修饰符的访问范围
1 | 访问级别 | 访问控制修饰符 | 同类 | 同包 | 子类 | 不同包 |
---|---|---|---|---|---|---|
2 | 公开 | public | √ | √ | √ | √ |
3 | 受保护 | protected | √ | √ | √ | × |
4 | 默认 | 没有修饰符 | √ | √ | × | × |
5 | 私有 | private | √ | × | × | × |
使用的注意事项
- 修饰符可以用来修饰类中的属性,成员方法以及类
- 只有默认的和public才能修饰类,并且遵循上述访问权限的特点
- 成员方法的访问规则和属性完全一样
package com.zanedu.modifier;public class A {//四个属性,分别使用不同的访问修饰符来修饰public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public void m1() {//该方法可以访问 四个属性//在同一个类中,可以访问 public、protected、默认、privateSystem.out.println("n1=" + n1 + " n2=" + n2 + " n3=" + n3 + " n4=" + n4);}protected void m2() { }void m3() { }private void m4() { }public void hi() {//在同一个类中,可以访问 public、protected、默认、privatem1();m2();m3();m4();}
}
package com.zanedu.modifier;public class Test {public static void main(String[] args) {A a = new A();a.m1();B b = new B();b.say();}
}//只有 默认 和 public 可以修饰类
class Tiger {}
package com.zanedu.modifier;public class B {public void say() {A a = new A();//在同一个包下,可以访问 public protected 和 默认,不能访问 private 属性或方法System.out.println("n1=" + a.n1 + " n2=" + a.n2 + " n3=" + a.n3);a.m1();a.m2();a.m3();
// a.m4();//error}
}
package com.zanedu.pkg;import com.zanedu.modifier.A;public class Test {public static void main(String[] args) {A a = new A();//在不同包下,可以访问public 修饰的属性或方法//但是不能访问 protected、默认、private修饰的属性和方法System.out.println(a.n1);a.m1();
// a.m2();//error
// a.m3();//error
// a,m4();//error}
}
面向对象编程三大特征
- 封装、继承、多态
封装
基本介绍
- 封装就是把抽象出的的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的操作[方法],才能对数据进行操作
封装的理解和好处
- 隐藏实现细节**:方法(连接数据库)<–调用(传入参数)**
如:具体的实现细节都被整合成了一个按钮,而用户只需要点击相应按钮就可以实现某些操作
- 可以对数据进行验证,保证安全合理
如:添加限制条件:名字要求2-4个字符
封装的实现步骤(三步)
- 将属性进行私有化private【即不能直接修改属性】
- 提供一个公共的(public)set方法,用于对属性判断并赋值
public void setXxx(类型 参数名) {//Xxx 表示某个属性
//加入数据验证的业务逻辑
属性 = 参数名
}
- 提供一个公共的(public)get方法,用于获取属性的值
public 数据类型 getXxx() {//权限判断,Xxx 某个属性
return xx;
}
案例入门
一个小程序,不能随便查看人的年龄、工资等隐私,并对设置的年龄进行合理的验证。年龄合理就设置,否则就给默认年龄,必须在1-120,年龄,工资不能直接查看,name的长度在2-6字符之间
分析:
- 不能随便查看人的年龄、工资等隐私,那就是私有类型private
- 设置的年龄,name要进行验证,那就要给个判断,即封装
代码
package com.zanedu.encap;public class Encapsulation01 {public static void main(String[] args) {Person person = new Person();
// person.name = "jack";ok
// person.age = 3000;error, 私有无法访问
// person.setName("jack");
// person.setName("jacktomcat 你好吗");person.setName("Zan");person.setAge(300);person.setSalary(3000);System.out.println(person.info());
// System.out.println(person.getSalary());//如果我们直接使用构造器指定属性Person smith = new Person("smith", 2000, 50000);System.out.println("=========smith的信息==========");System.out.println(smith.info());}
}//不能随便查看人的年龄,工资等隐私,并对设置的年龄进行合理的验证。
//年龄合理就设置,否则给默认 年龄, 必须在 1-120, 年龄, 工资不能直接查看 , name 的长度在 2-6 字符 之间
//工资是自己能够设置,但不能够查看,因此在getsalary里面加入需求class Person {public String name;private int age;private double salary;//有三个属性的构造器public Person(String name, int age, double salary) {// this.name = name;
// this.age = age;
// this.salary = salary;//我们可以将set方法写在构造器中,这样仍然可以验证,仍然可以判断setName(name);//等价于this.setName 因为是在同一个类中setSalary(salary);setAge(age);}//构造器public Person() {}//自己写setXXX 和 getXXX 太慢,可以使用快捷键//然后根据要求来完善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=" + salary;}//自己写setXXX 和 getXXX 太慢,可以使用快捷键
// public void setName(String name) {// this.name = name;
// }
// public String getName() {// return name;
// }}
快捷键快速生成 setXxx 和 getXxx
- 1. ctrl + insert
- 2. 选中Getter 和 Setter
- 也可以右键 --> 生成(进入此界面)
年龄超出的情况
名字长度不对的情况
将构造器和 setXxx结合
加入构造器后,会发现我们封装的限制条件被打破了,不会判断了
解决
- 可以将set方法写在构造器中,这样仍然可以验证,仍然可以判断,即在构造器里面运用set方法,让其判断
练习题
创建程序,在其中定义两个类:Account 和 AccountTest类体会Java的封装性
- Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)、密码(必须是6位),如果不满足,则给出提示信息,并给默认值(自己定)
- 通过setXxx的方法给Account的属性赋值
- 在AccountTest中测试
package com.zanedu.encap;//1. Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)、密码(必须是6位)
// 如果不满足,则给出提示信息,并给默认值
//2. 通过setXXXX 的方法给Account的属性复制
//3. 在AccountTest中测试import java.sql.SQLOutput;public class Account {//为了封装,将3个属性全都设置为privateprivate String name;private double balance;private String password;//提供两个构造器public Account() {}public Account(String name, double balance, String password) {// this.name = name;
// this.balance = balance;
// this.password = password;this.setName(name);this.setBalance(balance);this.setPassword(password);}public String getName() {return name;}public void setName(String name) {//姓名(长度为2位3位或4位)if (name.length() >= 2 && name.length() <= 4) {this.name = name;} else {System.out.println("名字要求长度为2位3位或4位, 默认值 无名");this.name = "无名";}}public double getBalance() {return balance;}public void setBalance(double balance) {//余额(必须>20)if (balance > 20) {this.balance = balance;} else {System.out.println("要求余额(必须>20), 默认为0");
// this.balance = 0;//可以不写,因为原先的默认值就是0}}public String getPassword() {return password;}public void setPassword(String password) {//密码(必须是6位)if (password.length() == 6) {this.password = password;} else {System.out.println("密码必须是6位,默认密码为 000000");this.password = "000000";}}//显示账号信息public void showInfo() {//可以增加一个权限的校验//先判断身份是不是合法的,如果合法就走下来
// if () {// System.out.println("账号信息 name=" + name + "余额=" + "balance");//密码就不显示了
// } else {//
// }System.out.println("账号信息 name=" + name + " 余额=" + balance);//密码就不显示了}
}
继承
引入
- 当我们使用几个类的时候,发现几个类里面的属性和方法有很多是相同的,那我们该怎么办 ==> 继承(代码复用性)
基本介绍和示意图
继承可以解决代码复用让我们的编程更加靠近人类思维,当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过extends来声明继承父类即可
继承的基本语法
class 子类 extends 父类 {
}
- 子类就会自动拥有父类定义的属性和方法
- 父类又叫超类、基类
- 子类又叫派生类
继承给编程带来的便利
- 代码的复用性提高了
- 代码的扩展性和维护性提高了
案例入门
代码
package com.zanedu.extend_.improve;import com.zanedu.extend_.Graduate;
import com.zanedu.extend_.Pupil;public class Extends01 {public static void main(String[] args) {com.zanedu.extend_.Pupil pupil = new Pupil();pupil.name = "小明~";pupil.age = 11;pupil.testing();pupil.setScore(50);pupil.showInfo();System.out.println("======================");com.zanedu.extend_.Graduate graduate = new Graduate();graduate.name = "大强~";graduate.age = 21;graduate.testing();graduate.setScore(100);graduate.showInfo();}
}
package com.zanedu.extend_.improve;public class Graduate extends Student{public void testing() {//和Pupil不一样System.out.println("大学生" + name + " 正在考大学数学");}
}
package com.zanedu.extend_.improve;//让Pupil类继承Student类
public class Pupil extends Student{public void testing() {System.out.println("小学生 " + name + " 正在考小学数学");}
}
package com.zanedu.extend_.improve;
//父类、是 Pupil 和 Gradate 的父类
public class Student {//共有属性public String name;public int age;private double score;//共有的方法public void setScore(double score) {this.score = score;}public void showInfo() {System.out.println("学生名 " + name + " 年龄 " + age + " 成绩 " + score);}
}
继承的深入讨论/细节问题(重要)
- 子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访问,要通过父类提供公共的方法去访问
- 子类
package com.zanedu.extend_;//输入 ctrl + H 可以看到类的继承关系
public class Sub extends Base{public Sub() { //无参构造器System.out.println("子类Sub()构造器被调用....");}public void sayOK() { //子类方法//非私有的属性和方法可以在子类直接访问//私有的属性和方法不能在子类直接访问System.out.println(n1);System.out.println(n2);System.out.println(n3);
// System.out.println(n4);error 私有的属性和方法不能在子类直接访问test100();test200();test300();
// test400();error//要通过父类提供公共的方法去访问System.out.println(getN4());callTest400();//}
}
- 父类
package com.zanedu.extend_;public class Base { //父类//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public Base() { //无参构造器System.out.println("Base()...");}//父类提供一个public的方法public int getN4() {return n4;}public void test100() {System.out.println("test100");}public void test200() {System.out.println("test200");}void test300() {System.out.println("test300");}private void test400() { //私有的不能直接访问System.out.println("test400");}public void callTest400() {test400();}
}
- 用父类提供的公共的方法去调用
- 子类必须调用父类的构造器,完成父类的初始化
- 调用
package com.zanedu.extend_;public class ExtendsDetail {public static void main(String[] args) {Sub sub = new Sub();//创建了子类对象 sub//sub.sayOK();}
}
- 子类
package com.zanedu.extend_;//输入 ctrl + H 可以看到类的继承关系
public class Sub extends Base{public Sub() { //无参构造器System.out.println("子类Sub()构造器被调用....");}
}
- 父类
package com.zanedu.extend_;public class Base { //父类//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public Base() { //无参构造器System.out.println("Base()...");}
}
- 当子类在创建一个对象的时候,一定会调用父类的构造器,完成父类的初始化
- 当创建子类对象时,不管使用子类的哪个构造器,默认情况总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作,否则,编译器不会通过
package com.zanedu.extend_;//输入 ctrl + H 可以看到类的继承关系
public class Sub extends Base{public Sub() { //无参构造器//这里其实隐藏了一句话,
// super();//默认调用父类的无参构造器 - 写不写都一样,反正一定有super("smith", 10);System.out.println("子类Sub()构造器被调用....");}//当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器public Sub(String name) {//super 在使用时,必须放在构造器第一行(super 只能在构造器中使用,不能在成员方法里使用)super("tom", 21);//do nothing...System.out.println("子类Sub(String name)构造器被调用");}
}
package com.zanedu.extend_;public class Base { //父类public Base() { //无参构造器System.out.println("Base()...");}public Base(String name, int age) { //有参构造器System.out.println("父类Base(String name, int age)构造器被调用....");}public Base(String name) {System.out.println("父类Base(String name)构造器被调用....");}
}
- 当父类没有无参构造器的时候,子类使用构造器,必须super显式调用某个构造器,不然会报错
- 如果父类没有无参构造器了,被其他构造器覆盖了,那么就得在子类的所有构造器中去super指定使用父类的哪个构造器,以此来完成父类的初始化工作
- 父类
package com.zanedu.extend_;public class Base { //父类//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public Base() { //无参构造器 - 现在已经被其他的构造器覆盖了,因此没有无参构造器了System.out.println("Base()...");}public Base(String name, int age) { //有参构造器System.out.println("父类Base(String name, int age)构造器被调用....");}public Base(String name) {System.out.println("父类Base(String name)构造器被调用....");}
}
- 这里子类设置了两个构造器,因此需要super两次
- 如果希望指定去调用父类的某个构造器,则显式的调用一下:super(参数列表)
- super在使用时,必须放在构造器第一行(super只能在构造器中使用)
- super() 和 this() 都只能放在构造第一行,因此这两个方法不能共存在一个构造器
- Java所有类都是Object类的子类,Object是所有类的基类
- 父类构造器的调用不限于直接父类!将一直往上追溯直到Object类(顶级父类)
- 爷爷辈
package com.zanedu.extend_;public class TopBase {public TopBase() {//默认也是有super(); Object的无参构造器System.out.println("构造器TopBase() 被调用...");}
}
- 当创建子类的时候,由于继承父类,因此会初始化父类,而父类又继承爷爷辈,因此会优先初始化爷爷辈
- 子类最多只能继承一个父类(指直接继承),即Java中是单继承机制
- 思考:如何让 A 类继承 B 类和 C 类?【A 继承 B,B 继承 C】
- 不能滥用继承,子类和父类之间必须满足 is-a 的逻辑关系
- 例如:music 类如何能继承 person 类
继承的本质分析(重要)
案例:当子类继承父类,创建子类对象时,内存中到底发生了什么?
提示:当子类对象创建好后,建立查找的关系
package com.zanedu.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);System.out.println(son.hobby);}
}class GrandPa { //爷类String name = "大头爷爷";String hobby = "旅游";
}
class Father extends GrandPa { //父类String name = "大头爸爸";int age = 39;
// private int age = 39;//如果变成私有的,内存当中还是有的,但是不能访问//解决方法:用公有的方法来访问到私有的属性
// public int getAge() {// return age;
// }
}
class Son extends Father { //子类String name = "大头儿子";
}
- 情况:变成私有后,内存当中还是有的,但是不能访问,因此如果在访问age 的时候,即使在GrandPa 爷类里面有公有的age类,那也会访问不到,直接报错,因为优先访问到Father 父类的age,但是是私有的,因此报错
super关键字
基本介绍
- super代表父类的引用,用于访问父类的属性、方法、构造器
基本语法:
- 访问父类的属性,但不能访问父类的private属性 - super.属性名;
- 访问父类的方法,不能访问父类的private方法 - super.方法名(参数列表);
- 访问父类的构造器 - super(参数列表);
注意:只能放在构造器中的第一句,并且只能出现一句
A类
package com.zanedu.super_;public class A extends Base{//四个属性public int n1 = 100;protected int n2 = 200;int n3 = 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() {}
}
B类
package com.zanedu.super_;public class B extends A {//访问父类的属性,但不能访问父类的private属性//super.属性名public void hi() {System.out.println(super.n1 + " " + super.n2 + " " + super.n3);//n4私有不能访问} //访问父类的方法,不能访问父类的private方法//super.方法名(参数列表);public void ok() {super.test100();super.test200();super.test300();
// super.test400();//error}//访问父类的构造器(这点前面用过)//super(参数列表),但只能放在构造器的第一句,只能出现一句public void hello() {// super();//error,必须在构造器里面}
}
- n4私有属性不能访问
- test400私有方法,不能访问
- super(参数列表) - 调用必须是第一条语句
super给变成带来的便利/细节
- 调用父类的构造器的好处(分工明确,父类属性由父类初始化,子类的属性由子类初始化)
- 当子类中有和父类中的成员(属性和方法)重名时,为了访问父类的成员,必须通过super,如果没有重名,使用super、this、直接访问是一样的效果
B类
package com.zanedu.super_;public class B extends A {public int n1 = 888;//编写测试方法public void test() {//super的访问不限于直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员//如果多个基类(父类)中都有同名的成员,使用super访问遵循就近原则:A->B->CSystem.out.println("super.n1=" + super.n1);//100//如果向访问到Base类的n1,就可以将父类A的n1注释掉,这样就可以访问到Base类的n1super.cal();//如果向访问到Base类的cal()方法,就可以将父类A的cal()方法注释掉,这样就可以访问到Base类的cal()方法}public void cal() {System.out.println("B类的cal()方法");}public void sum() {System.out.println("B类的sum()方法");//希望调用父类A的cal()方法//这时因为子类B中没有cal()方法,因此可以使用下面三种方法//cal();//找cal方法时,顺序是,(1)先找本类,如果有并且可以调用,则调用,//(2)如果没有则找父类(如果有,并可以调用,则调用)//(3)如果父类没有,则继续找父类的父类,逻辑一样,直到Object类//提示:如果查找过程中,找到了,但不能访问,则报错 cannot access//提示:如果查找过程中,没有找到,则提示方法不存在this.cal();//逻辑跟cal()完全一样//super.cal();//没有查找本类的过程,直接进入第二步(查找父类),其他逻辑一样//演示访问属性的规则//n1 和 this.n1 的查找规则一样//跟属性一样,也是私有的不能访问System.out.println(n1);//先找本类,本类没有,再去找父类System.out.println(this.n1);//同上一样//super直接去父类找,不会在本类找System.out.println(super.n1);}public B() {super();//ok - 由于在父类中自主定义了无参构造器,而不是默认的,因此可以调用//如果没有自主定义的无参构造器,去使用的时候,默认的无参构造器已经被覆盖了,而导致没有,会报错
// super("jack", 10);
// super("jack");}
}
A类
package com.zanedu.super_;public class A extends Base{//四个属性public int n1 = 100;protected int n2 = 200;int n3 = 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() {}
}
- super01类 - 主函数
package com.zanedu.super_;public class Super01 {public static void main(String[] args) {B b = new B();//子类对象
// b.sum();b.test();}
}
- super的访问不限于直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员,如果多个基类(上级类)中都有同名的成员,使用super访问遵循就近原则,A->B->C,当然也需要遵循访问权限的相关规律
- 演示访问属性的规则
super和this的比较
方法重写/覆盖(override)
基本介绍
- 简单来说,方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法
入门练习
- Animal类
package com.zanedu.override_;public class Animal {public void cry() {System.out.println("动物叫唤..");}
}
- Dog类
package com.zanedu.override_;public class Dog extends Animal{//1. 因为 Dog 是 Animal 的子类//2. Dog 的 cry 方法和 Animal 的 cry 方法定义形式一样(名称、返回类型、参数)//3. 这时我们就说 Dog 的 cry方法,重写了Animal的cry方法public void cry() {System.out.println("小狗汪汪叫..");}
}
- Override01
package com.zanedu.override_;public class Override01 {public static void main(String[] args) {//演示方法重写的情况Dog dog = new Dog();dog.cry();}
}
注意事项和使用细节
- 子类的方法的形参列表,方法名称要和父类方法的形参列表,方法名称完全一样
- 子类方法的返回类型和父类方法返回类型一样,或者是父类返回类型的子类,比如:父类返回类型是Object,子类方法饭回来先是String
package com.zanedu.override_;public class Animal {public void cry() {System.out.println("动物叫唤..");}public Object m1() {return null;}public String m2() {return null;}public AAA m3() {return null;}protected void eat() {}
}
package com.zanedu.override_;public class Dog extends Animal{//1. 因为 Dog 是 Animal 的子类//2. Dog 的 cry 方法和 Animal 的 cry 方法定义形式一样(名称、返回类型、参数)//3. 这时我们就说 Dog 的 cry方法,重写了Animal的cry方法public void cry() {System.out.println("小狗汪汪叫..");}//细节:子类方法的返回类型和父类方法返回类型一样// 或者是父类返回类型的子类,比如:父类返回类型是Object,子类返回类型是Stringpublic String m1() {return null;}
// public Object m1() {// return null;
// }//这里 Object 不是 String 的子类,因此报错
// public Object m2() {// return null;
// }// public AAA m3() { //ok
// return null;
// }
// public BBB m3() { //ok
// return null;
// }
// public String m3() { //error
// return null;
// }//细节:子类方法不能缩小父类方法的访问权限//public > protected > 默认 > privatepublic void eat() {}
}class AAA {}
class BBB extends AAA {}
- 子类方法不能缩小父类方法的访问权限:public > protected > 默认 > private
方法重写和重载的比较
多态
引入
- 请编写一个程序,Master类中有一个feed(喂食)方法,可以完成主人给动物喂食物的信息
利用传统的方法来解决(private属性)
- 就需要创建多个类
package com.zanedu.poly_;public class Animal {private String name;public Animal(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}
package com.zanedu.poly_;public class Bone extends Food{public Bone(String name) {super(name);}
}
package com.zanedu.poly_;public class Cat extends Animal{public Cat(String name) {super(name);}
}
package com.zanedu.poly_;public class Dog extends Animal{public Dog(String name) {super(name);}
}
package com.zanedu.poly_;public class Fish extends Food{public Fish(String name) {super(name);}
}
package com.zanedu.poly_;public class Food {private String name;public Food(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}
package com.zanedu.poly_;public class Master {private String name;public Master(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}//使用多态管理,可以统一的管理主人喂食的问题//animal 的编译类型是Animal,可以指向(接收) Animal子类的对象//food 编译类型是Food,可以指向(接受) Food子类的对象public void feed(Animal animal, Food food) {System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());}//主人给小狗喂食骨头
// public void feed(Dog dog, Bone bone) {// System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " + bone.getName());
// }
//
// //主人给小猫喂食小黄鱼
// public void feed(Cat cat, Fish fish) {// System.out.println("主人 " + name + " 给 " + cat.getName() + " 吃 " + fish.getName());
// }//如果动物很多,事物很多//===> feed 方法很多,不利于管理和维护//Pig --> Rice//Tiger --> meat}
package com.zanedu.poly_;public class Pig extends Animal{public Pig(String name) {super(name);}
}
package com.zanedu.poly_;public class Rice extends Food{public Rice(String name) {super(name);}
}
多[多种]态[状态]基本介绍
- 方法或对象具有多种形态。是面向对象的第三大特征,多态是建立在封装和继承基础之上的
多态的具体体现
- 重写和重载就体现多态
package com.zanedu.poly_;public class PolyMethod {public static void main(String[] args) {//方法重载体现多态A a = new A();//我们通过不同的参数去调用sum方法,就会去调用不同的方法//因此对sum方法来说,就是多种状态的体现System.out.println(a.sum(10, 20));System.out.println(a.sum(10, 20, 30));//方法重写体现多态B b = new B();a.say();b.say();}
}class B { //父类public void say() {System.out.println("B say() 方法被调用...");}
}class A extends B { //子类public int sum(int n1, int n2) {return n1 + n2;}public int sum(int n1, int n2, int n3) {return n1 + n2 + n3;}public void say() {System.out.println("A say() 方法被调用");}
}
对象的多态(重点)
- 一个对象的编译类型和运行类型可以不一致
- 编译类型在定义对象时,就确定了,不能改变
- 运行类型时可以变化的
- 编译类型看定义时等号的左边,运行类型看等号的右边
package com.zanedu.poly_.objectpoly_;public class PolyObject {public static void main(String[] args) {//体验对象多态特点//animal 编译类型就是 Aniaml,运行类型就是 DogAnimal animal = new Dog();//因为运行时,这时就运行到该行时,animal运行类型是Dog,所以cry就是Dog的cryanimal.cry();//小狗汪汪叫...//animal 编译类型就是 Aniaml,运行类型就是 Catanimal = new Cat();animal.cry();}
}
package com.zanedu.poly_.objectpoly_;public class Dog extends Animal{public void cry() {System.out.println("Dog cry() 小狗汪汪叫...");}
}
package com.zanedu.poly_.objectpoly_;public class Cat extends Animal{public void cry() {System.out.println("Cat cry() 小猫喵喵喵...");}
}
package com.zanedu.poly_.objectpoly_;public class Animal {public void cry() {System.out.println("Animal cry() 动物叫唤....");}
}
多态快速入门案例
- 使用多态的机制来解决主人喂食物的问题
package com.zanedu.poly_;public class Poly01 {public static void main(String[] args) {Master tom = new Master("汤姆");Dog dog = new Dog("大黄");Bone bone = new Bone("大棒骨~");tom.feed(dog, bone);Cat cat = new Cat("小花");Fish fish = new Fish("小黄鱼~");tom.feed(cat, fish);//添加给小猪喂食米饭Pig pig = new Pig("小花猪");Rice rice = new Rice("米饭");tom.feed(pig, rice);}
}
多态注意事项和细节讨论
- 多态的前提是:两个对象(类)存在继承关系
多态的向上转型:
本质:父类的引用指向了子类的对象
语法:父类类型 引用名 = new 子类类型();
特点:编译类型看左边,运行类型看右边
- 可以调用父类中的所有成员(但需遵守访问权限)
- 不能调用子类中特有成员
- 最终运行效果看子类的具体实现
多态的向下转型
语法:子类类型 引用名 = (子类类型)父类引用
只能强转父类的引用,不能强转父类的对象
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后,可以调用子类类型中所有的成员
- 属性没有重写之说!属性的值看编译类型
- instanceOf 比较操作符,用于判断对象的运行类型是否为XX类型或者XX类型的子类型
Java的动态内存绑定机制(重要)
- Java重要特性:动态绑定机制
- 当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定
- 当调用对象属性时,没有动态绑定机制,哪里声明,那就在哪里使用
package com.zanedu.poly_.dynamic_;public class DynamicBinding {public static void main(String[] args) {A a = new B();//向上转型System.out.println(a.sum());//40 将子类的sum注释后 从 40->30System.out.println(a.sum1());//30 将子类的sum1注销后,从30->20}
}
class A {public int i = 10;//动态绑定机制://1. 当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定//2. 当调用对象属性时,没有动态绑定机制,哪里声明,哪里使用public int sum() {return getI() + 10;}public int sum1() {return i + 10;}public int getI() { //父类return i;}
}class B extends A {public int i = 20;// public int sum() {// return i + 20;
// }public int getI() { //子类return i;//返回子类的20}// public int sum1() {// return i + 10;
// }
}
多态的应用
多态数组
- 数组的定义类型为父类类型,里面保存的实际元素类型为子类类型
应用实例
- 现有一个继承结构如下:要求创建1个Person对象,2个Student对象和2个Teacher对象,统一放在数组中,并调用每个对象的say()方法
- 如何调用子类特有的方法,比如Teacher有teach,Student有一个student,如何调用 - 向下转型
- PolyArray类
package com.zanedu.poly_.polyarr_;public class PolyArray {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("tom", 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++) {//persons[i] 编译类型是Person,运行类型是根据实际情况由JVM判断System.out.println(persons[i].say());//动态绑定数组//这里就得类型判断 + 向下转型if (persons[i] instanceof Student) { //判断persons[i]的运行类型是不是StudentStudent student = (Student)persons[i];//向下转型student.study();//也可以使用一条语句
// (Student)person[i].study();} else if (persons[i] instanceof Teacher) {Teacher teacher = (Teacher)persons[i];teacher.teach();} else if (persons[i] instanceof Person){//不提示} else {System.out.println("你的类型有误,请自行检测...");}
// persons[i].teach();
// persons[i].study();}}
}
- Person类
package com.zanedu.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;}
}
- Student类
package com.zanedu.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方法@Overridepublic String say() {return super.say() + " score=" + score;}public void study() {System.out.println("学生 " + getName() + " 正在学java");}
}
- Teacher类
package com.zanedu.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方法public String say() {return super.say() + " salary=" + salary;}//应用实例升级:如何调用子类特有的方法,//比如 Teacher 有一个 teach , Student 有一个 study 怎么调用?public void teach() {System.out.println("老师 " + getName() + " 正在讲java课程...");}
}
多态参数
- 方法定义的形参类型为父类类型,实参类型允许为子类类型
应用实例
定义员工类Employee,包含姓名和月工资[private],以及计算年工资getAnnual的方法,普通员工和经理继承了员工,经理类多了奖金bonus属性和管理manage方法,普通员工类多了work方法,普通员工和经理类要求分别重写getAnnual方法
测试类中添加一个方法showEmpAnnual(Employee e),实现获取任何员工对象的年工资,并在main方法中调用该方法[e.getAnnual()]
测试类中添加一个方法,testWork,如果是普通员工,则调用work方法,如果是经理,则调用manage方法
- PolyParameter类
package com.zanedu.poly_.polyparameter_;public class PolyParameter {public static void main(String[] args) {Worker worker = new Worker("tom", 2500);Manager manager = new Manager("milan", 5000, 20000);PolyParameter polyParameter = new PolyParameter();polyParameter.showEmpAnnual(worker);polyParameter.showEmpAnnual(manager);polyParameter.testwork(worker);polyParameter.testwork(manager);}//showEmpAnnual(Employee e)//完成获取任何员工对象的年工资,并在main方法中调用该方法 [e.getAnnual()]public void showEmpAnnual(Employee e) {System.out.println(e.getAnnual());//动态绑定机制}//添加一个方法,testWork,如果是普通员工,则调用work方法,如果是经理,则调用manage方法public void testwork(Employee e) {if (e instanceof Worker) {((Worker)e).work();//向下转型操作} else if (e instanceof Manager) {((Manager)e).manage();//向下转型操作} else {System.out.println("不做处理");}}
}
- Manage类
package com.zanedu.poly_.polyparameter_;public class Manager extends Employee{private double bonus;public Manager(String name, double salary, double bonus) {super(name, salary);this.bonus = bonus;}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}public void manage() {System.out.println("经理 " + getName() + " 正在管理");}//重写获取年薪方法@Overridepublic double getAnnual() {return super.getAnnual() + bonus;}
}
- Employee类
package com.zanedu.poly_.polyparameter_;public class Employee {private String name;private double salary;public Employee(String name, double salary) {this.name = name;this.salary = salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}//得到年工资的方法public double getAnnual() {return 12 * salary;}
}
- Worker类
package com.zanedu.poly_.polyparameter_;public class Worker extends Employee{public Worker(String name, double salary) {super(name, salary);}public void work() {System.out.println("普通员工 " + getName() + " 正在工作");}public double getAnnual() { //因为普通员工没有其他收入,则直接调用父类方法return super.getAnnual();}
}
Object类详解
equals方法
== 和 equals 的对比(面试题)
==是一个比较运算符,equals是一个方法
- ==:既可以判断基本类型,又可以判断引用类型
- ==:如果判断基本类型,判断的值是否相等
- ==:如果判断引用类型,判断的是地址是否相等,即判定是不是同一个对象
package com.zanedu.Object_;public class Equals01 {public static void main(String[] args) {A a = new A();A c = a;System.out.println(a == c);//trueSystem.out.println(a == c);//trueB bObj = a;System.out.println(bObj == c);//trueint num1 = 10;double num2 = 10.0;System.out.println(num1 == num2);//基本数类型,判断数值是否相等 - true}
}class A{}
**equals:是Object类中的方法,**只能判断引用类型
默认判断的是地址是否相同,因此子类中往往重写该方法,来用于判断内容是否相等
package com.zanedu.Object_;public class Equals01 {public static void main(String[] args) {A a = new A();A c = a;System.out.println(a == c);//trueSystem.out.println(a == c);//trueB bObj = a;System.out.println(bObj == c);//trueint num1 = 10;double num2 = 10.0;System.out.println(num1 == num2);//基本数类型,判断数值是否相等 - true//equals 方法,源码怎么查看,//把光标放在equals方法,ctrl + B转到源码 或 ctrl + 鼠标左键/*//String类 的 equals方法//把Object的equals方法重写了,变成了比较两个字符串值是否相同public boolean equals(Object anObject) {if (this == anObject) { //如果是同一个对象return true;//返回true}return (anObject instanceof String aString)&& (!COMPACT_STRINGS || this.coder == aString.coder)&& StringLatin1.equals(value, aString.value);}*/"hello".equals("abc");//看看Object类的equals/*//即Object 的equals 方法默认就是比较对象地址是否相同//也就是判断两个对象是不是同一个对象Objectpublic boolean equals(Object obj) {return (this == obj);}*//*Integer//从源码可以看到 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("zanedu");String str2 = new String("zanedu");System.out.println(str1 == str2);//falseSystem.out.println(str1.equals(str2));//true// new Object();}
}class A extends B{}
class B {}
如何重写equals方法
- 应用实例:判断两个Person对象的内容是否相等,如果两个Person对象的各个属性值一样,则返回true,反之false
package com.zanedu.Object_;public class EqualsExercise01 {public static void main(String[] args) {//重写equals方法//判断两个Person对象的内容是否相等,如果两个Person对象的各个属性值都一样,则返回true,反之falsePerson person1 = new Person("jack", 10, '男');Person person2 = new Person("jack", 10, '男');Person person3 = new Person("smith", 20, '男');System.out.println(person1.equals(person2));//false - 未重写的情况//true - 重写之后的情况System.out.println(person3.equals(person1));//false}
}class Person { //默认extends Object - Object类里面的equals方法就是==,相当于比地址private String name;private int age;private char gender;//重写Object 的 equals方法public boolean equals(Object obj) {//判断如果比较的两个对象是同一个对象,则直接返回trueif (this == obj) { //this 表示当前对象return true;}//类型判断if (obj instanceof Person) { //是Person类才比较//进行类型转换 - 向下转型 - 为了获得子类中的所有属性//因为我需要得到obj的各个属性Person person = (Person)obj;return this.name.equals(person.name) && this.age == person.age && this.gender == person.gender;}//如果不是Person,则直接返回falsereturn false;}public Person(String name, int age, char gender) {this.name = name;this.age = age;this.gender = gender;}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 char getGender() {return gender;}public void setGender(char gender) {this.gender = gender;}
}
hashCode方法
总结:
- 提高具有哈希结构的容器的效率
- 两个引用,如果指向的是同一个对象,则哈希值肯定是一样的
- 两个引用,如果指向的是不同对象,则哈希值是不一样的
- 哈希值主要根据地址号来的,但是不能完全将哈希值等价于地址,可以当作地址来看,但不是地址
package com.zanedu.Object_;public class HashCode_ {public static void main(String[] args) {AA aa = new AA();AA aa2 = new AA();AA aa3 = aa;System.out.println("aa.hashCode=" + aa.hashCode());System.out.println("aa2.hashCode=" + aa2.hashCode());System.out.println("aa3.hashCode=" + aa3.hashCode());}
}class AA {}
toString方法
- 基本介绍:
默认返回:全类名+@+哈希值的十六进制
子类往往重写toString方法,用于返回对象的属性信息
重写toString方法,打印对象或拼接对象时,都会自动调用该对象的toString形式
当直接输出一个对象时,toString方法会被默认的调用,比如System.out.println(monster),就会默认调用monster.toString()
package com.zanedu.Object_;public class ToString {public static void main(String[] args) {/*Object的toString() 源码//(1)getClass.getName() 类的全类名(包名+类名)//(2)Integer.toHexString(hashCode() 将对象的hashCode值转成16进制字符串public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}*/Monster monster = new Monster("小妖怪", "巡山的", 1000);//自身有一个toString,就不会去调用Object的toString了System.out.println(monster.toString() + " hashCode=" + monster.hashCode());System.out.println(monster);//等价 monster.toString()}
}class Monster {private String name;private String job;private double sal;public Monster(String name, String job, double sal) {this.name = name;this.job = job;this.sal = sal;}//重写toString方法,输出对象的属性//使用快捷键即可 alt+insert -> toString@Overridepublic String toString() { //重写后,一般是把对象的属性值输出,当然程序员也可以自己定制return "Monster{" +"name='" + name + '\'' +", job='" + job + '\'' +", sal=" + sal +'}';}
}
- 未重写情况
- 十六进制的转换
- 默认调用
finalize方法(实际开发基本不用,应付面试)
- 当对象被回收时,系统自动调用该对象的finalize方法,子类可以重写该方法,做一些释放资源的操作
- 什么时候被回收:当某个对象没有任何引用时,则JVM就认为这个对象是一个垃圾对象,就会使用垃圾回收机制来销毁该对象,在销毁该对象前,会先调用finalize方法
- 垃圾回收机制的调用,是由系统来决定(则有自己的GC算法),也可以通过System.gc()主动触发垃圾回收机制
package com.zanedu.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//快捷键可以生成@Overrideprotected void finalize() throws Throwable {// super.finalize();//这个是调用父类Object的方法//自己的写法System.out.println("我们销毁汽车" + name);System.out.println("释放了某些资源.....");}
}
- 有些JDK版本已经将finalize这个方法弃用了,不用了,如我用的JDK17就不能用
断点调试(Debug)
引入+基本介绍
引入:
- 在开发中,新手程序员在查找错误时,这时老程序员就会温馨提示,可以用断点来调试,一步一步的看源码执行的过程,从而发现错误所在
- 重要提示:在断点调试过程中,是运行状态,是以对象的运行类型来执行的
A extends B; B b = new A(); b,xx();
基本介绍:
- 断点调试是指在程序的某一行设置一个断点,调试时,程序运行到这一行就会挺住,然后你可以一步一步往下调试,调试过程中可以看各个变量当前的值,出错的话,调试到出错的代码行即显示错误,停下。进行分析从而找到这个Bug
- 断点调试是程序员必须掌握的技能
- 断点调试也能帮助我们查看Java底层源代码的执行过程,提高程序员的Java水平
断点调试的快捷键
F7(跳入)
F8(跳过)
shift + F8(跳出)
F9(resume,执行到下一个断点,即可以打多个断点)
F7(跳入方法内)
F8(逐行换行代码)
shift + F8(跳出方法)
Java面向对象编程(中级部分)相关推荐
- Java面向对象编程(中级)
面向对象编程(中级) 包 访问修饰符 封装 01: public class Encapsulation01 {public static void main(String[] args){Perso ...
- (JAVA) 面向对象编程(中级部分)
韩顺平老师==>视频链接 文章目录: 1.IDE(集成开发环境)-IDEA 1.1IDEA 介绍 2.IDE(集成开发环境)-Eclipse 2.1Eclipse 介绍 3.IDE(集成开发环境 ...
- Java学习笔记 六、面向对象编程中级部分
Java学习笔记 六.面向对象编程中级部分 包 包的注意事项和使用细节 访问修饰符 访问修饰符的注意事项和使用细节 面向对象编程三大特征 封装 封装的实现步骤(三步) 继承 继承的细节问题 继承的本质 ...
- (韩顺平)08 面向对象编程(中级部分)(自用)
目录 08 面向对象编程(中级部分) 8.1 IDE(集成开发环境)-IDEA 8.1.1IDEA 介绍 8.2 IDE(集成开发环境)-Eclipse 8.2.1Eclipse 介绍 8.3 IDE ...
- java面向对象编程知识点总结
一:今天完成 上午详细了解了java面向对象编程的一些细节,记录如下. 1)类 是一种引用类型,包含一个签名和一个主体,主体是放在花括号里面的成员,成员包括字段和方法,还有构造方法.初始化程序和嵌套类 ...
- Java面向对象编程篇6——注解与反射
Java面向对象编程篇6--注解与反射 1.注解概述 Java 注解(Annotation)又称 Java 标注,是 JDK5.0 引入的一种注释机制 Java 语言中的类.方法.变量.参数和包等都可 ...
- Java面向对象编程篇5——枚举
Java面向对象编程篇5--枚举 1.枚举的概念 在日常生活中这些事物的取值只有明确的几个固定值,此时描述这些事 物的所有值都可以一一列举出来,而这个列举出来的类型就叫做枚举类型 2.枚举的定义 使用 ...
- Java面向对象编程篇4——内部类
Java面向对象编程篇4--内部类 1.内部类的概念 当一个类的定义出现在另外一个类的类体中时,那么这个类叫做内部类 (Inner),而这个内部类所在的类叫做外部类(Outer). 类中的内容:成员变 ...
- Java面向对象编程篇3——接口与抽象类
Java面向对象编程篇3--接口与抽象类 1.接口(interface) 接口中可以含有变量和方法.但是要注意,接口中的变量会被隐式地指定为public static final变量(并且只能是pub ...
最新文章
- LeoFS —— 高可靠性的分布式对象存储系统
- linux安装redis 完整步骤
- Python基础05 缩进和选择
- 【计算机系统设计】重点 · 学习笔记(0)
- pip 不是内部或外部命令 也不是可运行的程序_QT之程序打包发布
- 为什么Java 中1000==1000为false,而100==100为true?
- 子网ip和子网掩码不匹配_【详解】你知道什么是IP路由查找的“最长匹配原则”吗?...
- Oracle - crfclust.bdb文件太大
- js数字比较【牢记】
- 【音频处理】使用 Adobe Audition 录制电脑内部声音 ( 启用电脑立体声混音 | Adobe Audition 中设置音频设备 | Adobe Audition 内录 )
- keychron的机械键盘
- 2016年全球超级计算机榜首是,中国神威·太湖之光荣登全球超级计算机500强榜首...
- 时间序列预测框架--Darts--快速开始(下)
- 360度全景拍摄,探索全景世界带你飞跃视野新高度
- 计算机阵列的定义,磁盘阵列是什么有什么好处?怎么组成磁盘阵列呢?
- 东芝存储器株式会社计划搬迁总部
- xml文件的注释展示
- linux的sh脚本编程
- 详解IP分片与TCP分段的区别
- 80后要坚守的人生底线