Java程序设计03——面向对象编程核心（1）

面向对象编程核心（1）

---

1.private关键字

private:是一个权限修饰符，用来修饰成员变量和方法，作用是保护成员不被别的类使用，只能在本类中访问

对于被private修饰的成员变量，如果别的类要修改或者想直接打印出来，需提供对应方法：
get变量名() ···获取变量值，用public修饰
set变量值（）···设置变量值，用public修饰

public void show(){
     System.out.println(name + "," +age);
     }

Student s = new Student();
s.setAge(20);
s.setName("zhang"）;
s.show();

System.out.println(s.getName() + "···" + s.getAge());

2.封装

封装：将某些信息隐藏在类内部，若要访问或修改这些变量，需要对应的setXX()/getXX()方法，使用private关键字。

3.继承：子类会有父类的内容（成员变量和方法），也有自己的内容

public class 子类 extends 父类名（）{
...
}

Tip：

Java中不支持多继承，但支持多层继承

4.super:父类对象的应用

表示父类的成员变量：super.成员变量
使用父类的构造方法：super(不填/参数)
使用父类的成员方法：super.成员方法（不填/参数）
System.out.println(super.age) ···父类的age

5.继承中构造方法的访问特点

每个子类的构造方法的第一句都是super() ，意味着子类所有的构造方法都默认会访问父类中的无参的构造方法。

如果父类中没有无参的构造方法，最好的办法是自己给出一个无参的构造方法去给它调用，不然会报错。

6.方法重写

方法重写：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，方法名不变，核心重写

@Override：是一个注解，会帮我们检查重写的正确性

Tip：

私有方法不能重写，子类方法访问权限不能更低(public>默认>private)

7.修饰符

不同修饰符修饰的类或者方法，有不同的调用范围

8.final关键字

作用范围：可以修饰成员，方法，类
特点：final是最终的意思，修饰的成员，方法和类不能再被赋值，再被重写和继承

9.static关键字

变量：所有类共享的变量使用static修饰
方法：想通过类名调用的方法，使用static修饰
静态方法不能直接访问非静态成员。

public class Pool{
    public static int water = 0;
    public static void inlet(){
      water = water +3;
      }
}

public static void main(String[] args){
    Pool pool1 = new Pool();···本应有这行代码，但因inlet()为静态方法，可以直接调用，所以只需下面一行代码
    Pool.inlet();
}

10.多态

1.三个必要条件：

1）要有继承；
2）要有重写；
3）父类引用指向子类对象。

public class Animal{
      public void eat(){
           System.out.println("动物吃东西");
           }
     }
     
public class Cat extends Animal{
      @Override
      public void eat(){
           System.out.println("猫吃鱼");
           }
     }   
     
public class AnimalDemo{
       public static void main(String[] args){
       //有父类应用指向子类对象
       Animal a = new Cat();

2.成员访问特点

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

public class Animal{
      public int age = 40;
      
      public void eat(){
           System.out.println("动物吃东西");
           }
     }
     
public class Cat extends Animal{
      public int age =20;
      public int weight = 10;
      
      @Override
      public void eat(){
           System.out.println("猫吃鱼");
           }
           
      public void play(){
           System.out.println("猫玩玩具");
           }
     }   
     
public class AnimalDemo{
       public static void main(String[] args){
       //有父类应用指向子类对象
       Animal a = new Cat();
       
       //Animal类中有这个成员变量，所以可以编译，执行的也是Animal中的值
       System.out.println(a.age);
       //因为Animal类中没有这个成员变量，所以无法编译
       System.out.println(a.weight);
       
       //Animal类中有这个方法，所以可以编译，执行的是Cat类中的方法
       a.eat();
       //Animal类中没有这个方法，所以不可以编译
       a.play():

3.多态的优点

可以在定义方法时，使用父类型做参数，将来使用的时候，使用具体的子类型参与操作

public class Animal{
      public void eat(){
           System.out.println("动物吃东西");
           }
     }
     
public class Cat extends Animal{
      @Override
      public void eat(){
           System.out.println("猫吃鱼");
           }
     }  
     
public class AnimalOperator{
       public void useAnimal(Animal a){
            //相当于Animal a = new Cat();
            //相当于Animal a = new Dog();
            a.eat()
            }
            
public class AnimalDemo{
       public static void main(String[] args){
       //创建动物操作类的对象
       AnimalOperator ao = new AnimalOperator();
       
       //可以直接调用猫类的方法
       Cat c = new Cat();
       ao.useAnimal(c);
       打印结果：猫吃鱼
       
       //直接调用赞加的狗类的方法
       Dog d = new Dog();
       ao.useAnimal(d);
       打印结果：狗吃骨头
 
//如果我想添加别的动物的方法，只需创建一个动物子类，然后可以在AnimalDemo类中直接调用

public class Dog extends Animal{
      @Override
      public void eat(){
           System.out.println("狗吃骨头");
           }
     }  

4.向上和向下转型

1）向上转型：从子到父，父类应用指向子类对象(较具体的类转化为较抽象的类）
2）向下转型：从父到子，父类应用转为子类对象(较抽象的类转化为较具体的类）

Animal.java:
public class Animal{
         public void eat(){
                System.out.println("动物吃东西");
                }
           }
           
Cat.java:
public class Cat extends Animal{
         @Override
         public void eat(){
                System.out.println("猫吃鱼");
                }
                
         public void play(){
                System.out.println("猫捉迷藏");
                }
           }
           
AnimalDemo:
public void AnimalDemo{
          public staic void main(String[] args){
                 //向上转型，但不能使用play（）方法
                 Animal a = new Cat();
                 a.eat();

                 //向下转型，可以使用play()方法
                 Cat c = (Cat)a;
                 c.eat();
                 c.play();          

5.方法重载
重载(overloading)： 是在一个类里面，方法名字相同，,、返回类型可以相同也可以不同，但参数必须不同。

public class TestOverLoad1 {
public int add(int a, int b) {
    return a+b;
     }

public float add(float a, float b) {
    return a+b;
      }
}

public float add(float a, float b,float c) {
    return a+b+c;
      }
}