文章目录
Java SE从入门到放弃（十一)之Eclipse快捷键总结以及继承和重写
一、Eclipse中全部快捷键总结
Eclipse中的快捷键：
* 1.补全代码的声明：alt + /
* 2.快速修复: ctrl + 1
* 3.批量导包：ctrl + shift + o
* 4.使用单行注释：ctrl + /
* 5.使用多行注释： ctrl + shift + /
* 6.取消多行注释：ctrl + shift + \
* 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
* 8.删除指定行的代码：ctrl + d
* 9.上下移动代码：alt + up 或 alt + down
* 10.切换到下一行代码空位：shift + enter
* 11.切换到上一行代码空位：ctrl + shift + enter
* 12.如何查看源码：ctrl + 选中指定的结构 或 ctrl + shift + t
* 13.退回到前一个编辑的页面：alt + left
* 14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
* 15.光标选中指定的类，查看继承树结构：ctrl + t
* 16.复制代码： ctrl + c
* 17.撤销： ctrl + z
* 18.反撤销： ctrl + y
* 19.剪切：ctrl + x
* 20.粘贴：ctrl + v
* 21.保存： ctrl + s
* 22.全选：ctrl + a
* 23.格式化代码： ctrl + shift + f
* 24.选中数行，整体往后移动：tab
* 25.选中数行，整体往前移动：shift + tab
* 26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
* 27.批量修改指定的变量名、方法名、类名等：alt + shift + r
* 28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
* 29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
* 30.调出生成getter/setter/构造器等结构： alt + shift + s
* 31.显示当前选择资源(工程 or 文件)的属性：alt + enter
* 32.快速查找：参照选中的Word快速定位到下一个 ：ctrl + k
* 33.关闭当前窗口：ctrl + w
* 34.关闭所有的窗口：ctrl + shift + w
* 35.查看指定的结构使用过的地方：ctrl + alt + g
* 36.查找与替换：ctrl + f
* 37.最大化当前的View：ctrl + m
* 38.直接定位到当前行的首位：home
* 39.直接定位到当前行的末位：end
二、面向对象的特征二：继承性
1. 说明
* 一、继承性的好处？
* 继承的出现减少了代码冗余，提高了代码的复用性。
* 继承的出现，更有利于功能的扩展。
* 继承的出现让类与类之间产生了关系，提供了多态的前提。
* 二、继承的格式： class A extends B
* 其中：类A: 子类、SubClass
* 类B: 父类、SuperClass、超类、基类
* 三、说明
* 1. 子类在继承父类以后，就获取了父类中声明的属性、方法。
* >对于父类中声明为private的结构，在子类继承父类以后，是可以获取到了的，只是由于封装性的影响，我们在子类中不可以直接调用。
* 2. 此外，子类还可以在父类的基础上，定义自己额外的属性或方法。
* 此时的子类、父类的关系不同于子集与集合的关系。extends：扩展、延展
* 四、注意点：
* 1. 开发中，不能为了继承而继承。需要满足实际中的包含关系
* 2. java中规定，类与类之间只能是单继承的。反之，一个父类可以声明多个子类
* 3. 子类父类是相对的概念
* 4. 明确：直接父类与间接父类的概念
* 5. 继承以后，子类除了能获取直接父类中的结构之外，还可以获取所有的间接父类中的结构。
2. 理解
3. 代码
public class Creature {//生物
public void breath(){
System.out.println("呼吸");
}
}
public class Person extends Creature{
String name;
private int age;
public Person(){
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void walk(){
System.out.println("走路");
}
public void show(){
System.out.println("name : " + name +", age : " + age);
info();
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private void info(){
System.out.println("我是一个快乐的人");
}
}
public class Student extends Person{
//不需要再声明
// String name;
// int age;
String major;//专业
public Student(){
}
public Student(String name, int age) {
this.name = name;
// this.age = age;
setAge(age);
}
public Student(String name, int age, String major) {
this.name = name;
// this.age = age;
setAge(age);
this.major = major;
}
//不需要再声明
// public void eat(){
// System.out.println("吃饭");
// }
//
// public void walk(){
// System.out.println("走路");
// }
public void study(){
System.out.println("好好学习！天天向上");//good good study,day day up!
}
}
测试类：
public class ExtendsTest {
public static void main(String[] args) {
Student s = new Student();
//直接调用父类Person中的属性
s.name = "陈丹华";
// s.age = 21;
//替换为：
s.setAge(21);
s.major = "计算机科学与技术";
s.study();
//如下的方法，调动的就是父类中声明的方法
s.eat();
s.walk();
s.show();
s.breath();
}
}
4. 练习
(1)定义一个ManKind类，包括
成员变量int sex和int salary；
方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；
方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
(2)定义类Kids继承ManKind，并包括
成员变量int yearsOld；
方法printAge()打印yearsOld的值。
(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。
答案：
public class ManKind {
private int sex;
private int salary;
public void manOrWoman(){
if(sex == 1){
System.out.println("man");
}else if(sex == 0){
System.out.println("woman");
}
}
public void employeed(){
if(salary == 0){
System.out.println("no job");
}else{
System.out.println("job");
}
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
}
public class Kids extends ManKind{
private int yearsOld;
public void printAge(){
System.out.println("I am " + yearsOld + " years old.");
}
public int getYearsOld() {
return yearsOld;
}
public void setYearsOld(int yearsOld) {
this.yearsOld = yearsOld;
}
}
public class KidsTest {
public static void main(String[] args) {
Kids someKid = new Kids();
someKid.setSalary(0);
someKid.setSex(1);
someKid.setYearsOld(12);
someKid.manOrWoman();
someKid.employeed();
someKid.printAge();
}
}
三、方法的重写(override、overwrite)
* 1.方法的重载(overload) “两同一不同” ； 方法和构造器都可以重载。
*
* 2. 方法的重写：子类在继承父类以后，可以对父类中同名同参数的方法进行覆盖、复写。此过程就称为方法的重写。
*
* 比如：
* class Account{//账户
* double balance;
* public void withdraw(double amt){} //被重写的方法
* }
*
* class CheckingAccount extends Account{//信用卡账户
* double money = 20000;//可透支额度
*
* public void withdraw(double amt){ //重写父类的方法
* //先从balance中扣减；balance如果不足，再从money中扣减
* }
* }
*
* 3. 方法的重写的规则
* 复习： 方法的声明
* 权限修饰符 返回值类型 方法名(形参列表){//方法体}
*
* ① 子类重写父类的方法与父类被重写的方法的"方法名"和"形参列表"必须相同
* ② 子类重写父类的方法 的权限修饰符 不小于 父类中被重写的方法的权限修饰符
* 特别的：子类不能重写父类中声明为private的方法。
* ③ > 如果父类中的方法返回值类型为：void,则子类重写的方法的返回值类型也必须为void
* > 如果父类中的方法返回值类型为：基本数据类型，则子类重写的方法的返回值类型也必须为相同的基本数据类型
* > 如果父类中的方法返回值类型为：引用数据类型，则子类重写的方法的返回值类型与父类被重写的方法的返回值类型相同，或是其子类
* ④ 关于抛出异常的要求，放到异常处理章节再讲。
*
* ***************************************************
* 额外的：子父类中同名同参数的方法必须同时为static的，或者同时为非static的（考虑重写）。
*
* 补充：构造器不可以重写
四、super关键字
1. super调用属性、方法
* super关键字的使用。 --->this:当前对象、当前正在创建的对象；this(形参列表)
*
* 1. 可以理解为：父类的
* 2. 可以用来调用：父类的属性、方法、构造器
*
* 3. super调用父类的属性、方法
* ① 在子类的方法或构造器中，可以通过super.属性或super.方法的方式，显式的调用父类中声明的属性或方法。
* 但是一般情况下，我们都选择省略此super关键字。
* ② 但是，当子类与父类中出现同名的属性时，必须使用super.属性的方式，表明调用的是父类中同名的属性 （这种情况尽量不要发生）
* ③ 当子类中需要调用父类中被重写的方式时，一定要使用super.方法的方式，表明调用的是父类中被重写的方法。
public class Person {
String name;
int id = 1001;//身份证号
public Person(){
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void walk(){
System.out.println("走路");
}
}
public class Student extends Person {
String major;// 专业
int id = 1002;//学号
public Student() {
}
public Student(String name, int age) {
this.name = name;
setAge(age);
}
public Student(String name, int age, String major) {
this.name = name;
setAge(age);
this.major = major;
}
@Override
public void walk() {
System.out.println("学生背着书包走路");
}
public void study() {
System.out.println("好好学习！天天向上");// good good study,day day up!
// this.walk();
super.walk();
show();
}
public void StudentInfo(){
System.out.println("name = " + this.name);
System.out.println("id = " + super.id);//1001
System.out.println("major = " + this.major);
System.out.println("id = " + this.id);//1002
}
}
2. super调用父类构造器
4. super调用父类的构造器
* ① 我们可以在子类的构造器中使用"super(形参列表)"的方式，显式的调用父类中的指定的构造器。
* ② 当我们没有在子类构造器的首行声明"super(形参列表)"或"this(形参列表)"的方式时，默认使用了"super()"的结构。
* ③ 如果在子类构造器中使用父类构造器的话，必须将"super(形参列表)"声明在构造器的首行。
* ④ 在子类构造器的首行，只能声明super(形参列表)或this(形参列表)，不能同时存在。
* ⑤ 一个类中有n个构造器，则至多有n-1个构造器中使用this(形参列表),至少有一个使用了super(形参列表)
*
* 5. 如果一个类没有显示的声明其父类的话，则默认的父类为：java.lang.Object类。
public class Student extends Person {
String major;// 专业
int id = 1002;//学号
public Student() {
}
public Student(String name, int age) {
//super();
this.name = name;
setAge(age);
}
public Student(String name, int age, String major) {
super(name,age);
this.major = major;
}
}
构造器，则至多有n-1个构造器中使用this(形参列表),至少有一个使用了super(形参列表)
*
-
- 如果一个类没有显示的声明其父类的话，则默认的父类为：java.lang.Object类。
```java
public class Student extends Person {
String major;// 专业
int id = 1002;//学号
public Student() {
}
public Student(String name, int age) {
//super();
this.name = name;
setAge(age);
}
public Student(String name, int age, String major) {
super(name,age);
this.major = major;
}
}
如果对你有帮助的话，可不可以帮我一键三连呢？
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
