Java知识点细节简易汇总——(6)面向对象编程(中级部分)

一、IDE快捷键

  1. 删除当前行, 默认是 ctrl + Y 自己配置 ctrl + d
  2. 复制当前行, 自己配置 ctrl + alt +向下光标
  3. 补全代码 alt + /
  4. 添加注释和取消注释 ctrl + / 【第一次是添加注释,第二次是取消注释】
  5. 导入该行需要的类 先配置 auto import , 然后使用 alt+enter 即可
  6. 快速格式化代码 ctrl + alt +L
  7. 快速运行程序 自己定义 alt + R
  8. 生成构造器等 alt + insert [提高开发效率]
  9. 查看一个类的层级关系 ctrl + H [学习继承后,非常有用]
  10. 将光标放在一个方法上,输入 ctrl + B ,可以定位到方法 [学继承后,非常有用]
  11. 自动的分配变量名 , 通过 在后面加 .var [老师最喜欢的]
  12. 还有很多其它的快捷键…

二、封装

构造器写在 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

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值