面向对象语言的三大特性：封装，继承，多态
封装：Encapsulation，意思是讲代码通过函数将一些代码细节包装起来来，防止外部代码的随机访问，要访问这些数据就必须通过调用函数来完成。
提高了代码的阅读性
提高了代码的可维护性
packagejava_learning;public classStudent {publicStudent() {
}privateString age;public void setAge(int age) {//可以通过对象来设置值 但是维护性差//推荐该种暴露方法去操作
this.age=age+"";//拼接编程字符串
}publicString getAge() {return this.age;
}
}packagejava_learning;public classTestStudent {public static voidmain(String[] args) {//TODO Auto-generated method stub
Student student=newStudent();
student.setAge(28);//设置属性
System.out.println(student.getAge());//获取属性
}
}
View Code
继承：Java中的继承就是两个类之间通过extends关键字来面熟父子关系，子类便可以拥有父类的公共方法和公共属性。
提高代码的复用性
代码的维护性更高
1.父类定义共有的行为
2.子类可以继承父类的公共方法和属性来复用
3.子类可以通过定义父类没有的方法或者通过覆盖父类的方法来实现扩展[覆盖可覆盖父类的属性和方法]
注意：1.子类不能继承父类的private属性和方法
2.Java是单继承(一个类只能继承于一个类)
3.创建本类对象之前会先初始化父类对象。
super和this的区别：
super和this的区别：
super是父类对象的引用【调用父类的方法和属性】
this是当前类对象的引用
packagejava_learning;public classXiMi1 {public String brand="小米1";public XiMi1() {//无参的构造方法
System.out.println("我是小米1 的无参构造方法");
}public XiMi1(String name) {//有参构造方法
System.out.println("我是"+name+" 的有参构造方法");
}public voidsendMsg() {
System.out.println("发送短信");
}public voidcall() {
System.out.println("打电话");
}public voidtest() {
System.out.println("我是父类，父类的测试方法");
}
}
View Code
packagejava_learning;public class XiMi2 extendsXiMi1 {publicXiMi2() {//super();//调用父类的默认构造方法 一般不写，写和不写都有相同的效果，因为创建本类对象之前会先初始化父类对象。
super("小米1");//二选一 调用父类有参的构造方法
System.out.println("使用了super之后======================分割");
System.out.println("我是小米2的构造方法");
}publicXiMi2(String name) {super();//哈哈，二选一//super("小米1111111111");//父类和子类的构造方法都是要有参的
System.out.println("我是"+name+" 的有参构造方法");
}public String brand = "小米2";//属性的覆盖
public void swipe() {//父类没有，子类有，叫扩展
System.out.println("我是扩展，小米2可以滑屏");//仅仅只是为了学习
}
@Override//打个标志而已
public void test() {//子类覆盖父类的方法
super.test();//代表的是父类的一个引用 调用父类的方法
System.out.println("我是覆盖，子类的测试方法");
}
}
View Code
packagejava_learning;public classTestXiMi2 {public static voidmain(String[] args) {
XiMi2 xm2= newXiMi2();
XiMi2 xm3= new XiMi2("小米22222");
xm2.sendMsg();
xm2.call();
xm2.swipe();
xm3.test();
}
}
View Code
多态：
人：男人，女人
动物：猫，狗。
猫 x = new 猫();
动物 x = new 猫();
首先，什么是多态？我们应该从什么角度来理解多态？其实，我们不妨把多态理解成一种事物的多种存在形态，比如，猫和狗都可以变成动物，而动物又可以变成猫和狗。
为了充分理解多态，我们可以从以下这几个方面来理解多态。
第一、从多态的体现方面：我们使用多态的时候，创建的是父类的引用，开辟的是子类的空间，由于没有开辟父类的空间，所以是父类的引用指向子类对象，并不是真正的父类自己创建了对象，而且父类对象的引用还可以作为函数参数来接收子类对象哦！
第二、多态实现的前提：必须是类与类之间要有关系，要么继承，要么实现，存在覆盖，其实就是有抽象函数。
第三、从多态的好处：大大提高程序的可拓展性
第四、多态的应用：1.父类对象的引用指向子类对象，其实本质上是一个向上转型，就像int转成double一样，儿子穿了一身爸爸的衣服，扮成了爸爸。2.但变成了爸爸之后，只能使用爸爸特有的技能，儿子怎么能够使用自己本身的技能呢？这时候就需要向下转型，脱下伪装，将父类对象的引用强转成子类类型，就可以使用子类特有的技能了。
packagejava_learning;public classAnimal {publicString name;publicAnimal() {
}publicAnimal(String name) {
System.out.println(this.name);
}public voideat() {
System.out.println("父类在吃东西");
}
}
View Code
packagejava_learning;public class Cat extendsAnimal {publicString name;publicCat() {
}publicCat(String name) {this.name=name;
}public voideat() {
System.out.println(this.name + "在吃东西");
}
}
View Code
packagejava_learning;public class Dog extendsAnimal {public String name="小狗狗";publicDog() {
}publicDog(String name) {this.name=name;
}public voideat() {
System.out.println("小狗狗在吃东西");
}public voidbarking() {
System.out.println(this.name+"在汪汪叫");
}
}
View Code
多态应用：
packagejava_learning;public classTestAnimal {public static voidmain(String[] args) {//TODO Auto-generated method stub//创建的是父类的引用，开辟的是子类的空间，由于没有开辟父类的空间，所以是父类的引用指向子类对象，并不是真正的父类自己创建了对象，//而且父类对象的引用还可以作为函数参数来接收子类对象哦！
Animal cat =new Cat();//对象类型向上提升
cat.eat();
Cat cat2=new Cat("坚果");
cat2.eat();
Animal dog=new Dog();//对象类型向上提升
dog.eat();//dog.barking();//会报错
Dog dog1=(Dog)dog;//向下类型强制转换 再调用子类特有的方法时候，就需要向下强制类型转换
dog1.barking();//父类本身没有的方法，子类扩展
}
}
View Code
Java之接口：
接口是一种规范喝标准，他们可以约束类的行为，是一些方法特征的集合，但是方法是没有实现的。
new——interface (定义接口) 使用implements(实现接口)
特点：
接口里面的所有方法都是抽象的，public修饰，abstract类型，不能存在实现了的方法。
接口里的成员变量(全局变量)必须是public修饰，static final类型(static静态，不能用对象调用，可以用类名调用)
final(最终的，不能改变的)，换句话说就是变量的值必须是常量。
接口不能实例化，所以接口里是不能定义任何构造函数的；
接口可以多继承，一个接口可以继承多个接口。(类只能单继承)
packagejava_learning;public interfaceWorker {/** 工作：抽象的方法(未实现的方法)
**/
public voidwork();public static final String WORK="it小哥";
}
View Code
packagejava_learning;public class Teacher implementsWorker {
@Overridepublic voidwork() {
System.out.println("老师教书");
}public static voidmain(String[] args) {
System.out.println(Worker.WORK);
Teacher tec=newTeacher();
tec.work();
}
}
View Code
抽象类：
定义了抽象方法的类叫做抽象类。作用：无非就是想让子类实现差异化的方法。
抽象类里既可以定义抽象的方法来约束子类的行为，还可以定义实现方法，对于一些子类共有的实现方法，我们可以把他们抽出来放到抽象类里，子类直接从抽象类继承。
Java重载：
发生在同一个类中，函数同名，但是参数列表不一样：
参数个数不一样
参数类型不一样
参数顺序不一样
重载的作用：
Java重写：在继承中，子类修改了了父类的同一个方法[个人理解]
java之多态的使用
首先，什么是多态？我们应该从什么角度来理解多态？其实，我们不妨把多态理解成一种事物的多种存在形态，比如，猫和狗都可以变成动物，而动物又可以变成猫和狗。
为了充分理解多态，我们可以从以下这几个方面来理解多态。
第一、从多态的体现方面：我们使用多态的时候，创建的是父类的引用，开辟的是子类的空间，由于没有开辟父类的空间，所以是父类的引用指向子类对象，并不是真正的父类自己创建了对象，而且父类对象的引用还可以作为函数参数来接收子类对象哦！
第二、多态实现的前提：必须是类与类之间要有关系，要么继承，要么实现，存在覆盖，其实就是有抽象函数。
第三、从多态的好处：大大提高程序的可拓展性
第四、多态的应用：1.父类对象的引用指向子类对象，其实本质上是一个向上转型，就像int转成double一样，儿子穿了一身爸爸的衣服，扮成了爸爸。2.但变成了爸爸之后，只能使用爸爸特有的技能，儿子怎么能够使用自己本身的技能呢？这时候就需要向下转型，脱下伪装，将父类对象的引用强转成子类类型，就可以使用子类特有的技能了。
第五、多态的弊端：提高了拓展性，但是只能使用父类的引用访问父类的成员。
多态：可以理解为事物存在的多种体现形态。
人：男人，女人
动物：猫，狗。
猫 x = new 猫();
动物 x = new 猫();
多态的体现父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。
多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。
多态的好处多态的出现大大的提高程序的扩展性。
多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。
多态的应用
/*
动物，
猫，狗。
*/
abstract classAnimal{
abstractvoideat();
}
classCatextendsAnimal{
publicvoideat(){
System.out.println("吃鱼");
}
publicvoidcatchMouse(){
System.out.println("抓老鼠");
}
}
classDogextendsAnimal{
publicvoideat(){
System.out.println("吃骨头");
}
publicvoidkanJia(){
System.out.println("看家");
}
}
classPigextendsAnimal{
publicvoideat(){
System.out.println("饲料");
}
publicvoidgongDi(){
System.out.println("拱地");
}
}
//-----------------------------------------
classDuoTaiDemo{
publicstaticvoidmain(String[]args){
//Cat c = new Cat();
//c.eat();
//Dog d = new Dog();
//d.eat();
//Cat c = new Cat();
/*
Cat c1 = new Cat();
function(c1);
function(new Dog());
function(new Pig());
*/
//Animal c = new Cat();
//c.eat();
function(new Cat());
function(new Dog());
function(new Pig());
}
publicstaticvoidfunction(Animal a){
//Animal a = new Cat();
a.eat();
//a.catchMouse();
}
/*
public static void function(Cat c)// {
c.eat();
}
public static void function(Dog d) {
d.eat();
}
public static void function(Pig p) {
p.eat();
}
*/
}
多态：可以理解为事物存在的多种体现形态。
人：男人，女人
动物：猫，狗。
猫 x = new 猫();
动物 x = new 猫();
多态的体现父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。
多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。
多态的好处多态的出现大大的提高程序的扩展性。
多态的弊端：虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。
多态的应用
多态的出现代码中的特点(多态使用的注意事项)
第二个问题：如何使用子类特有方法。
/*
动物，
猫，狗。
*/
classCatextendsAnimal{
publicvoideat(){
System.out.println("吃鱼");
}
publicvoidcatchMouse(){
System.out.println("抓老鼠");
}
}
classDogextendsAnimal{
publicvoideat(){
System.out.println("吃骨头");
}
publicvoidkanJia(){
System.out.println("看家");
}
}
classPigextendsAnimal{
publicvoideat(){
System.out.println("饲料");
}
publicvoidgongDi(){
System.out.println("拱地");
}
}
//-----------------------------------------
classDuoTaiDemo2{
publicstaticvoidmain(String[]args){
//Animal a = new Cat();//类型提升。 向上转型。
//a.eat();
//如果想要调用猫的特有方法时，如何操作？
//强制将父类的引用。转成子类类型。向下转型。
///Cat c = (Cat)a;
//c.catchMouse();
//千万不要出现这样的操作，就是将父类对象转成子类类型。
//我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
//多态自始至终都是子类对象在做着变化。
// Animal a = new Animal();
// Cat c = (Cat)a;
/*
毕姥爷 x = new 毕老师();
x.讲课();
毕老师 y = (毕老师)x;
y.看电影();
*/
function(new Dog());
function(new Cat());
}
publicstaticvoidfunction(Animal a){
//Animal a = new Cat();
a.eat();
/*
if(a instanceof Animal) {
System.out.println("haha");
}
else
*/
if(a instanceof Cat) {
Cat c = (Cat)a;
c.catchMouse();
} else if(a instanceof Dog) {
Dog c = (Dog)a;
c.kanJia();
}
/* instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型) */
}
}
posted @ 2019-01-12 16:30 onefine 阅读(740) 评论(0) 编辑 收藏
2679
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
