面向对象的特点
一、面向对象的特点
1、封装
2、继承
3、多态
二、封装
1、封装的概念
将类中的成员（属性，方法，构造器） 设为private，只能在当前类的内部使用，外部无法访问。
2、企业的封装
主要用于属性的封装。
将属性设为私有的，提供公有的getter和setter方法来访问。
package com.fz;
public class Student {
// 封装属性，设为private
private int num;
private String name;
// 设置num属性的值
public void setNum(int num){
if(num<0){
return;
}
this.num=num;
}
// 获取num属性的值
public int getNum(){
return num;
}
// 设置name属性的值
public void setName(String name){
this.name=name;
}
// 获取name属性的值
public String getName(){
return name;
}
// 封装方法
// private void study(){
// System.out.println("i like study");
// }
// 封装构造器
// private Student(){}
}
package com.fz;
public class Test {
public static void main(String[] args) {
Student s= new Student();
// s.name="张三";
// s.num=1001;
s.setNum(1001);
s.setName("zhangsan");
System.out.println(s.getNum());
System.out.println(s.getName());
}
}
3、封装的优点
保证属性中的数据完整性。
保证属性的安全性。
三、继承
1、继承的概念
子类继承父类的属性和方法。
继承之后，在子类中就不需要再定义父类中的属性和方法。
2、继承的好处
减少重复代码的编写，提高了代码的重用性。
使用场景：
当你发现几个类中有重复的属性和方法时，将重复的属性和方法定义到父类中，其他类继承这个父类即可。
3、继承的实现
(1)语法
[修饰符] class 子类名 extends 父类名{
}
（2）案例
package com.jc;
public class Animal {
public String name;
public String type;
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
package com.jc;
public class Dog extends Animal{
// public String name;
// public String type;
//
// public void eat(){
// System.out.println("eat");
// }
//
// public void sleep(){
// System.out.println("sleep");
// }
}
package com.jc;
public class Cat extends Animal{
}
package com.jc;
public class ManDog extends Dog{
}
package com.jc;
public class Test {
public static void main(String[] args) {
// Dog d=new Dog();
// d.name="旺财";
// d.type="中华田园犬";
// System.out.println(d.name);
// System.out.println(d.type);
//
// d.eat();
// d.sleep();
// Cat c=new Cat();
// c.name="tom";
// c.type="波斯";
// System.out.println(c.name);
// System.out.println(c.type);
//
// c.eat();
// c.sleep();
ManDog manDog=new ManDog();
manDog.name="来福";
manDog.type="哈巴狗";
System.out.println(manDog.name);
System.out.println(manDog.type);
manDog.eat();
manDog.sleep();
}
}
4、子类的扩展
子类除了继承父类的属性和方法，还可以添加自己新的属性和方法。
子类比父类功能更强大。
package com.jc;
public class Dog extends Animal{
// public String name;
// public String type;
//
// public void eat(){
// System.out.println("eat");
// }
//
// public void sleep(){
// System.out.println("sleep");
// }
public void bite(){
System.out.println("咬人");
}
}
package com.jc;public class ManDog extends Dog{ public String sex;}
package com.jc;
public class Test {
public static void main(String[] args) {
// Dog d=new Dog();
// d.name="旺财";
// d.type="中华田园犬";
// System.out.println(d.name);
// System.out.println(d.type);
//
// d.eat();
// d.sleep();
// Cat c=new Cat();
// c.name="tom";
// c.type="波斯";
// System.out.println(c.name);
// System.out.println(c.type);
//
// c.eat();
// c.sleep();
ManDog manDog=new ManDog();
manDog.name="来福";
manDog.type="哈巴狗";
manDog.sex="公";
System.out.println(manDog.name);
System.out.println(manDog.type);
manDog.eat();
manDog.sleep();
manDog.bite();
}
}
5、继承的特点和范围
（1）继承特点
单继承：子类只能继承一个父类。
（2）多层次继承
A继承B，B继承C
C将属性和方法传给B，B再将属性和方法传给A。
（3）继承范围
子类只能继承父类的属性和方法，不能继承构造器！！
同包下，只能继承非私有的属性和方法。（继承的受保护和缺省的属性和方法只能用在子类中或者和父类同包的类中使用。）
不同包下，只能继承公共的和受保护的属性和方法。（继承的受保护的属性和方法只能用在子类中或者和父类同包的类中使用。）
package com.jc.aa;
import javax.swing.*;
public class P {
private int a=1;
int b=2;
protected int c=3;
public int d=4;
private void test1(){
System.out.println(11);
}
void test2(){
System.out.println(22);
}
protected void test3(){
System.out.println(33);
}
public void test4(){
System.out.println(44);
}
}
package com.jc.aa;
public class CC1 extends P{
public static void main(String[] args) {
CC1 c1=new CC1();
// System.out.println(c1.a);
System.out.println(c1.b);
System.out.println(c1.c);
System.out.println(c1.d);
// c1.test1();
c1.test2();
c1.test3();
c1.test4();
}
}
package com.jc.aa;
public class Test {
public static void main(String[] args) {
CC1 c1=new CC1();
// System.out.println(c1.a);
System.out.println(c1.b);
System.out.println(c1.c);
System.out.println(c1.d);
// c1.test1();
c1.test2();
c1.test3();
c1.test4();
}
}
package com.jc.bb;
import com.jc.aa.P;
public class CC2 extends P {
public static void main(String[] args) {
CC2 c2=new CC2();
// System.out.println(c2.a);
// System.out.println(c2.b);
System.out.println(c2.c);
System.out.println(c2.d);
// c2.test1();
// c2.test2();
c2.test3();
c2.test4();
}
}
package com.jc.bb;
public class Test2 {
public static void main(String[] args) {
CC2 c2=new CC2();
// System.out.println(c2.a);
// System.out.println(c2.b);
// System.out.println(c2.c);
System.out.println(c2.d);
// c2.test1();
// c2.test2();
// c2.test3();
c2.test4();
}
}
6、方法的重写override
子类继承父类的方法，但是该方法无法满足子类的需求，我们可以重新定义该方法。这个过程叫方法的重写。
重写的原则：
方法名相同
参数相同（参数名无所谓）
返回值类型相同
访问修饰符>=父类的范围
重写之后，子类对象执行的重写的方法体！！！
package com.jc.cc;
public class Father {
public String name;
public void eat(){
System.out.println(name+" eat food");
}
void smoke(){
System.out.println(name+" smoke sanhua");
}
}
package com.jc.cc;
public class Son extends Father{
// 缺省 protected public
//方法的重写
public void smoke(){
System.out.println(name+" smoke zhonghua");
}
}
package com.jc.cc;
public class Test {
public static void main(String[] args) {
Son s=new Son();
s.name="小明";
s.eat();
s.smoke();
}
}
7、super关键字
（1）super第一种用法
当子类中的属性和方法，与继承的父类的属性和方法重名了。
我们在子类中，直接访问是子类中定义的属性和重写的方法。
如果在子类中，我们想要访问父类被隐藏的属性和方法，需要使用super调用。
super.属性名
super.方法名(..)
super表示子对象的super区！！
（2）继承的原理：
（3）super第二种用法
super表示父类构造器！！！
我们创建子类对象时，new 子类构造器：
// 调用子类构造器创建子类的对象：
// 创建一个子类的对象；
// 系统会先调用父类的构造器，默认调用父类无参的构造器，来创建对象的super区；
// 然后调用指定的子类构造器，来创建对象的this区；
// 返回对象的this区首地址
如果你不想使用父类无参构造器来构建super区，那么必须需要使用：super(实参)来指定。
如果调用的是父类无参构造器，使用super();,可以省略不写。
注意：super（..）必须是子类构造器中的第1条语句！！！
（4）案例
package com.jc.dd;
public class P {
public String name="张三";
public int age;
public void eat(){
System.out.println("eat");
}
public void smoke(){
System.out.println("smoke sanhua");
}
public P(){
System.out.println("我是我父类构造器");
}
public P(int i){
age=i;
System.out.println("我是我父类构造器:"+i);
}
}
package com.jc.dd;
public class C extends P{
public String name="李四";
public String sex;
浙公网安备 33010602011771号