深圳专业的网站制作公司软件开发工具

面向对象的三大特征

1.封装

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装(数据的隐藏）通常应用于禁止直接访问一个对象中数据的实际表示，而应用通过操作接口来访问，这称为信息隐藏。

记住这句话就够了：属性私有，get/set

get和set

public class Student {//private属性私有private String name;private int age;private char sex;//get获取这个数据public String getName() {return name;}public int getAge() {return age;}//set 给这个数据设置值public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}//idea快捷键：alt+insert
}public class StudentDemo {public static void main(String[] args) {Student s1 = new Student();s1.setName("刘德华");   //使用set设置值为刘德华s1.setAge(50);System.out.println(s1.getName()+"今年"+s1.getAge()+"岁了"); //刘德华今年50岁了}
}

规范属性的合法化

如果这里age我们输入999

public class StudentDemo {public static void main(String[] args) {Student s1 = new Student();s1.setName("刘德华");   //使用set设置值为刘德华s1.setAge(999);System.out.println(s1.getName()+"今年"+s1.getAge()+"岁了"); //刘德华今年999岁了}
}

很明显没有人能活到999岁，所以这里我们必须做一些限制。

public class Student {//private属性私有private String name;private int age;private char sex;//get获取这个数据public String getName() {return name;}public int getAge() {return age;}//set 给这个数据设置值public void setName(String name) {this.name = name;}public void setAge(int age) {//输入的年龄超过范围则显示0if (age > 120 || age < 0 ){this.age = 0;} else {this.age = age;}}//快捷键：alt+insert
}

所以从某种意义上说，它可以规范属性的合法化。

2.继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
注意：JAVA中类只有单继承，没有多继承！

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。
• 子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有"is a"的关系

类继承

修饰符extends

//人
public class Person {
}//学生也是人，所以他是Person子类
public class Student extends Person {
}//老师也是人，所以他是Person子类
public class Teacher extends Person {
}

子类调用父类方法

//人
public class Person {public void say(){System.out.println("说话");}
}//学生
public class Student extends Person {
}public class test {public static void main(String[] args) {Student student = new Student();student.say();  //说话}
}//查询继承关系快捷键：Ctrl+H

子类集成父类，就会拥有父类的全部方法，之所以这样是因为我们所用的修饰符是public，同样的修饰符还有下面几个：

修饰符	意思	常用程度
public	公开的	重点最常用
protected	受保护的
default	默认的
private	私有的	重点最常用

在java中所有的类默认直接或间接的集成了object类。

super的用法

这里的super要和this一起说，我们可以对比。

通过super调用父类public的属性

//父类，人
public class Person {private String name ="kuangshen";
}//人的子类，学生类
public class Student extends Person {private String name = "qingjiang";public void test(String name){System.out.println(name);   //对象传入的nameSystem.out.println(this.name); //当前类的name，结果为”qingjiang”System.out.println(super.name);   //父类中的属性，结果为”kuangshen”}}

当父类的属性或者方法是私有时super也是无法调用的。

super注意点

• super调用父类的构造方法，必须在构造方法的第一行；

• super必须只能出现在子类的方法或者构造方法中；

• super和this不能同时调用构造方法，因为他们都需要放在第一行，所以不能同时！

super对比this

对比	代表的对象不同	前提	构造方法
this	本身调用者是对象	没有继承也可以使用	本类的构造
super	代表父类对象的应用	只能在继承条件才可以使用	父类的构造

‍

方法重写

静态方法中奇怪的现象

//父类
public class B {public static void test(){System.out.println("B=>test()");}
}//子类
public class A extends B {public static void test(){System.out.println("A=>test()");}
}//演示
public class ceshi {public static void main(String[] args) {A a = new A();  a.test();		//A=>test()B b = new A();b.test();       //B=>test()，我new的是A为何会结果是B=>test()？？？//而且可以看到，方法的调用跟等号右边没什么关系，因为右边都是new A()，但是却跟左边数据的定义有很大的关系；//父类的引用指向了子类，因为这和多态有关，我们先这么简单的理解。}
}

感觉方法的调用跟等号右边没什么关系，因为右边都是new A()，但是却跟左边数据的定义有很大的关系。

非静态方法

现在我们把上面A和B类中的static去掉

//父类
public class B {public void test(){System.out.println("B=>test()");}
}//子类
public class A extends B {@Override   //重写修饰符public void test(){System.out.println("重写方法");}
}//演示
public class ceshi {public static void main(String[] args) {A a = new A();  a.test();		//A=>test()B b = new A();  //子类重写了父类的方法b.test();       //重写方法}
}

注意：方法重写只跟非静态方法有关，和静态方法没有任何关系

3.多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式，一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

举例：一只猫

• 我们可以说猫是猫 cat=new 猫（）；
• 我们也可以说猫是动物animal=new 猫（）；
• 这里的猫在不同时刻表现出了不同的形态，这就是多态。

多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性。

多态中成员访问特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

为什么成员变量和成员方法的访问不一样呢？因为成员方法有重写，而成员变量没有

package com.pokes001;public class Person {public void run() {System.out.println("run");}
}package com.pokes001;public class Student extends Person {@Overridepublic void run(){System.out.println("run");}public void eat(){System.out.println("eat");}
}package com.pokes001;public class Application {public static void main(String[] args) {//一个对象的实际类型是确定的//new Student();//new Person();//父类的引用指向子类Student s1 = new Student();  //Student能调用自己的方法和继承父类的方法Person s2 = new Student();  //父类型，可以指向子类，但是不能调用子类独有的方法Object s3 = new Student();  //同上s1.eat(); //子类重写了父类的方法，执行子类方法//s2.eat();这个是直接报错，因为父类无法调用子类独有的方法}

多态的好处和弊端

多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

多态的弊端：不能使用子类的特有功能

多态中的转型

向上转型

父类为Animal，有一个eat()方法，打印：动物吃东西

子类为Cat，有两个方法，其中一个是重写了父类的eat()方法，打印：猫吃鱼。另一个方法为playGame方法，打印：猫捉迷藏

public class AnimaDemo{public static void main(String[] args){//向上转型，等号左边是动物类Animal，右边是猫对象Animal a = new Cat(); a.eat();  //猫吃鱼,调用了子类重写父类的方法//可以直接调用父类Animal的eat方法和子类重写父类的eat方法，但是不能调用子类独有的方法playGame，否则会报错。 }
}

可以直接调用父类Animal的eat方法和子类重写父类的eat方法，但是不能调用子类独有的方法playGame，否则会报错。

向下转型

根据上面的例子我们是无法调用playGame方法，但是有时候必须要调用，这个时候我们需要将Animal a = new Cat()向下转型

public class AnimaDemo{public static void main(String[] args){Animal a = new Cat(); //向下转型Cat c = (Cat)a;   //可以这样理解：将动物类强制转为猫类，并赋值给cc.eat();	//猫吃鱼	c.playGame() //猫捉迷藏}
}