JAVA(2)

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);

}