一、IDE快捷键
- 删除当前行, 默认是 ctrl + Y 自己配置 ctrl + d
- 复制当前行, 自己配置 ctrl + alt +向下光标
- 补全代码 alt + /
- 添加注释和取消注释 ctrl + / 【第一次是添加注释，第二次是取消注释】
- 导入该行需要的类 先配置 auto import , 然后使用 alt+enter 即可
- 快速格式化代码 ctrl + alt +L
- 快速运行程序 自己定义 alt + R
- 生成构造器等 alt + insert [提高开发效率]
- 查看一个类的层级关系 ctrl + H [学习继承后，非常有用]
- 将光标放在一个方法上，输入 ctrl + B ,可以定位到方法 [学继承后，非常有用]
- 自动的分配变量名 , 通过 在后面加 .var [老师最喜欢的]
- 还有很多其它的快捷键…
二、封装
构造器写在 public static void main(String[] args) { }之外
将构造器和 setXxx 结合
public static void main(String[] args) {
Person person = new Person();
person.setName("路飞");
person.setAge(25);
person.setSelerty(10000);
System.out.println(person.toString());
System.out.println("==================");
Person person1 = new Person("索隆", -1, 1);
System.out.println(person1.toString());
}
}
class Person{
public String name;
private int age;
private int selerty;
public Person() {
}
public Person(String name, int age, int selerty) {
this.name = name;
this.age= age;
this.selerty= selerty;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<100 && age>0) {
this.age = age;
}else {
System.out.println("错误");
}
}
public int getSelerty() {
return selerty;
}
public void setSelerty(int selerty) {
if (selerty>500)this.selerty = selerty;
else System.out.println("错误");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", selerty=" + selerty +
'}';
}
}
以上代码会有弊端：索隆的年纪为-1，却能通过！所以将构造器和 setXxx 结合
改进行代码如下：
public static void main(String[] args) {
Person person = new Person();
person.setName("路飞");
person.setAge(25);
person.setSelerty(10000);
System.out.println(person.toString());
System.out.println("==================");
Person person1 = new Person("索隆", -1, 1);
System.out.println(person1.toString());
}
}
class Person{
public String name;
private int age;
private int selerty;
public Person() {
}
public Person(String name, int age, int selerty) {
setSelerty(selerty);
setAge(age);
setName(name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<100 && age>0) {
this.age = age;
}else {
System.out.println("错误");
}
}
public int getSelerty() {
return selerty;
}
public void setSelerty(int selerty) {
if (selerty>500)this.selerty = selerty;
else System.out.println("错误");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", selerty=" + selerty +
'}';
}
}
三、继承
细节
在这里插入代码片
ps:第四点的方法是：super(“参数和需要调用的父类构造器的参数类型相同“);
第二点：
// 父 类
public class Person {
public Person() {
System.out.println("父类的构造器...");
}
}
// 子类
public class Student extends Person{
public Student() {
System.out.println("子类的构造器...");
}
}
public class Text {
public static void main(String[] args) {
Student student = new Student();
}
}
调用的是子类的构造器，但输出的时候父类的构造器也启动了…
原因：存在super(): 且默认调用父类的无参构造器…
public class Student extends Person{
public Student() {
//super(): 默认会存在，且默认调用父类的无参构造器...
System.out.println("子类的构造器...");
}
}
第三点后半句(如果父类默认没有提供无参构造器…)原因： 由第二点可知存在super(): 且默认调用父类的无参构造器.，但是由于父类没有提供无参构造器，所以解决方法就是手动写上super( ): 去指定说明调用的是父类的哪一个构造器。
四、super关键字
super 代表父类的引用，用于访问父类的属性、方法、构造器
五、重载VS重写
六、多态的魅力
多态的前提是类之间存在继承关系。
传统的方法带来的问题是什么? 如何解决?
问题是： 代码的复用性不高，而且不利于代码维护
解决方案： 引出我们要讲解的多
准备工作：
// Animal 父 类
public class Animal {
public void cry() {
System.out.println("Animal cry() 动物在叫....");
}
}
// Animal的子 类
public class Cat extends Animal {
public void cry() {
System.out.println("Cat cry() 小猫喵喵叫...");
}
}
// Animal的子 类
public class Dog extends Animal {
public void cry() {
System.out.println("Dog cry() 小狗汪汪叫...");
}
}
// Food 父 类
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;
}
}
// Food的子类
public class Bone extends Food{
public Bone(String name) {
super(name);
}
}
// food的子类
public class Fish extends Food {
public Fish(String name) {
super(name);
}
}
// 主 人
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;
}
//主人给小狗 喂食 骨头
public void feedDog(Dog dog, Bone bone) {
System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " +bone.getName());
}
// //主人给 小猫喂 黄花鱼
public void feedCat(Cat cat, Fish fish) {
System.out.println("主人 " + name + " 给 " + cat.getName() + " 吃 " + fish.getName());
}
}
测试：
public class poly {
public static void main(String[] args) {
Master master1 = new Master("李华");
Dog dog = new Dog("小狗狗");
Bone bone = new Bone("骨头");
master1.feedDog(dog, bone);
System.out.println("=================");
Master master2 = new Master("李明");
Cat cat = new Cat("小猫猫");
Fish fish = new Fish("鱼");
master2.feedCat(cat, fish);
}
}
得出结论 ：太过于繁琐。如果动物很多，食物很多feed 方法很多，不利于管理和维护。对Master进行多态改进。
// Master
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 class poly {
public static void main(String[] args) {
Master master = new Master("李华");
Dog dog= new Dog("小狗狗~");
Bone bone = new Bone("骨头~");
master.feed(dog, bone);
System.out.println();
System.out.println("=======================");
Cat cat= new Cat("小猫咪~");
Fish fish = new Fish("鱼~");
master.feed(cat, fish);
}
}
使用多态机制，可以统一的管理主人喂食的问题
animal 编译类型是 Animal,可以指向(接收) Animal 子类的对象
food编译类型是 Food ,可以指向(接收) Food 子类的对象
七、向上、下转型
向上转型
向上转型调用方法的规则如下:
(1)可以调用父类中的所有成员(需遵守访问权限)。
(2)但是不能调用子类的特有的成员。
(3)因为在编译阶段，能调用哪些成员,是由编译类型来决定的。
(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法，没有，则再在父类中查找，然后调用，规则我前面我们讲的方法调用规则一致。
向下转型
向下转型的条件：例如下方代码Text方法中：animal原先已经指向了Dog，所以才可以进行向下转型{ Dog cat = (Dog) animal}。
// 父 类
public class Animal {
public void eat() {
System.out.println("动物吃食物...");
}
public void run() {
System.out.println("动物跑...");
}
public void show() {
System.out.println("动物show...");
}
}
// 子 类
public class Dog extends Animal{
public void eat() {
System.out.println("狗吃骨头....");
}
public void dogcll() {
System.out.println("小狗的特有方法...");
}
}
public class Text {
public static void main(String[] args) {
//向上转型
Animal animal = new Dog();
animal.eat(); //狗吃骨头....
animal.run(); //动物跑...");
//animal.dogcll(); 错误！！！
//向下转型
Dog dog =(Dog)animal;
dog.dogcll();
}
}
向上转型： 按照从子类(运行类型)开始查找方法，若有则调用；若没有，则再在父类中查找，然后调用。
八、== 和 equal
443
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
