java面向对象编程的四大特征:
1、抽象
2、封装
3、继承
4、多态
封装
//职员 class Clerk { public String name; //private私有的 private int age; private float salary; public Clerk(String name,int age,float sal) { this.name=name; this.age=age; this.salary=sal; } //通过一个成员方法去控制和访问私有的属性 public float getSal() { return this.salary; }
java提供四种访问控制修饰符（控制方法和变量的访问权限）：
1.公开级别：用public修饰，对外公开
2.受保护级别：用protected修饰，对子类和同一个包中的类公开
3.默认级别：没有修饰符号，向同一个包的类公开
4.私有级别：用private修饰，只有类本身可以访问，不对外公开
包-必要性
包的三大作用：
区分相同名字的类
当类很多时，可以很好地管理类
控制访问范围
包的打包命令：
package com.xxx
包的命名规范：小写字母
java中常用包：
java.lang.* 自动引入
java.util.* 工具包
java.net.* 网络开发包
java.awt.* 窗口工具包
包的引入：
inport 包；（如：import java.awt.*;)
继承
class Pupil { //定义成员属性 private int age; private String name; private float fee; //交费 public void pay(float fee) ｛ ｔｈｉｓ．ｆｅｅ＝ｆｅｅ； ｝ ｝
继承解决类重复问题
所有的子类不需要重新定义属性和方法，只需要通过extends语句声明继承父类
class 子类 extends 父类
私有属性不能被继承（private）
继承－注意
子类最多只能继承一个父类（指直接继承）
ｊａｖａ所有类都是Object类的子类
ＪＤＫ６中有２０２个包３７７７个类、接口、异常、枚举、注释和错误
开发时多使用ｊｄｋ帮助文档
有些时候必须继承一些类来实现更多的功能：
package com.shun; import javax.swing.*; public class Demo2 extends JFrame { public static void main(String []args) { Demo demo2=new Demo2(); } public Demo2() { this.setVisible(true); this.setSize(200,200); } }
方法重载&方法覆盖
方法重载注意事项：
方法名相同
方法的参数类型，个数，顺序至少有一项不同
方法返回类型可以不同
方法的修饰符可以不同
<只是返回类型不一样，不能够构成重载>
方法的覆盖(子类有一个方法与父类的名称、返回值、参数一样）
public class Demo3{ public static void main(String []args){ //创建一只猫 Cat cat1=new Cat(); cat.cry(); dog1.cry(); } } class Animal { int age; String name; public void cry() { System.out.println("我是动物"); } } //猫猫类 class Cat extends Animal { //覆盖父类 public void cry() { System.out.println("猫猫叫"); } } //狗类 class Cat extends Animal { //覆盖父类 public void cry() { System.out.println("狗叫"); } }
注意：
1.子类方法的返回类型、参数、方法名称要和父类方法的返回类型、参数方法名称完全一样，否则编译出错。
2.子类方法不能缩小父类方法的访问权限。（比如public不能被protected覆盖）
多态
package com.shun; public class Demo5 { public static void main(String [] args){ //多态 /* Cat cat=new Cat(); cat.cry(); Dog dog=new Dog(); dog.cry();*/ Animal an=new Cat(); an.cry(); an=new Dog(); an.cry(); } } //动物类Animal class Animal { String name; int age; public String getName() { return name; } public void setName(String name) { this.name=name; } public int getAge() { return age; } public void setAge(int age){ this.age=age; } //动物会叫 public void cry() { System.out.println("不知道怎么叫"); } } class Dog extends Animal { //狗叫 public void cry() { System.out.println("狗叫"); } } class Cat extends Animal { //猫自己叫 public void cry() { System.out.println("猫叫");}
多态注意事项：
java允许父类的引用变量引用它的子类的实例（对象）Animal animal=new Cat();
这种转换自动完成；
多态定义：一个引用（类型）在不同情况下的多种状态。
抽象类的必要性：
package com.test2; public class Test { public static void main(String[] args) { } } abstract class Animal { String name; int age; //动物会叫 public void cry(); abstract public void cry(); } //当一个类继承的父类是抽象类的话，需要我们把抽象类中的所有抽象方法全部实现 class Cat extends Animal { //实现父类cry public void cry() { //do nothing System.out.println("猫叫"); } }
定义：
1、用abstract关键字来修饰一个类时，这个类就叫抽象类
2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法
3、抽象方法在编程中用的不多，但在公司笔试时较常见
注意：
1、抽象类不能被实例化
2、抽象方法不一定要包含abstract方法
3、一旦包含abstract方法，则这个类必须声明为abstract
4、抽象方法不能有主体
接口：给出一些没有内容的方法，封装到一起，要使用时将这些方法写出来
<class 类名 implements 接口{
方法；
变量；
}
>
接口：体现程序设计多态和高内聚低耦合的设计思想
<当一个类实现了一个接口，就要求该类把这个接口的所有方法统统实现
interface Usb{ //声明两个方法 //开始工作 public void start(); //停止工作 public void stop(); } //编写了照相机类 class Camera implements Usb{ public void start(){ System.out.println("开始工作"); } public void stop(){ System.out.println("停止工作"); } } class Phone implement Usb{ public void start(){ System.out.println("开始工作"); } public void stop(){ System.out.println("结束工作"); } } //计算机 class Computer{ //开始使用usb接口 public void useUsb(Usb usb){ usb.start(); usb.stop(); } } //接口继承别的接口 class Base{ } interface Tt{ } interface Son extends Tt{ } public class Demo4_2{ public static void main(String[] args){ System.out.println(Usb.a); Computer computer=new Computer(); //创建Camera Camera cameral=new Camera(); //创建Phone Phone phone1=new Phone(); computer.useUsb(camera1); computer.useUsb(phone1); }
