面向对象编程思想

Java开发是利用 面向对象 的思想实现 面向过程 的开发。

面向对象编程（OOP：Object-Oriented Programming）

1、基本概念：
（1）类：在现实世界中，对任何事物抽象的描述。是虚拟的，不存在的。
<1>类是一组具有相同属性和行为的对象的抽象。
<2>类的作用是用来创建对象，对象是类的一个实例。

（2）对象：现实世界中，看得见摸得着的，具体存在的事物。对象是系统中用来描述客观事物的一个实体。
<1>对象是构成世界的一个独立单位。
<2>具有自己的静态结构（属性）和动态方法（行为）。
<3>每个对象有自己的唯一标识。

（3）类与对象的关系
类是对象的抽象，对象是类的一个实例。抽象和具体的关系。

2、特征：封装、继承、多态
（1）封装：就是把客观事物封装成抽象的类，把对象的属性和行为结合在一个独立的类中，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
<1>封装可以隐藏实现细节，使得代码模块化。
<2>封装的目的是实现代码重用。

（2）继承：子类通过继承，可以获得父类的属性和方法，进行扩展。
<1>继承可以使用和扩展已存在的代码模块（类）。
<2>继承的目的是实现代码重用。

（3）多态：多形性，父类型引用指向子类型的实现，动态改变行为。一个class，随着不同的场景，它的表现形态，会随之发生变化。
<1>父类的引用，引用派生类（子类）的实例：
<2>父类的引用，调用重写后的方法
<3>在运行调用时形成多态
<4>多态的目的是实现接口重用
<5>多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

//创建一个调用方法      父类             引用名
public static void print(ObjectDemo   demo){
    //父类的引用调用重写后的方法
    //父类的引用.重写后的方法()
    if (demo.getAge() > 20) {
        System.out.println("老张的大儿子叫：" + demo.getName() + " 今年" + demo.getAge() );
    }
    if (demo.getName().equals("zhangyusheng")){
        System.out.println("老张的二儿子叫：" + demo.getName() + " 今年" + demo.getAge());
    }
}
//运行调用方法 
public static void main(String[] args){
//父类的引用，引用派生类（子类）的实例：父类  引用 = new 子类();
    ObjectDemo demo = new SonDemoA();
//父类的引用调用重写后的方法：引用.重写后的方法();  例如：demo.getName();        
    System.out.println(demo.getName());
    System.out.println(demo.getAge());
    System.out.println("==================================");
    //在运行调用时形成多态
    print(new SonDemoA());
    System.out.println("==================================");   
    print(new SonDemoB());
    System.out.println("==================================");
    }
}
//父类
class ObjectDemo{
    public int getAge(){
        return 50;
    }
    public String getName(){
        return "zhangsan";
    }
}
//子类继承父类，重写父类的方法
class SonDemoA extends ObjectDemo{
    //override：方法重写
    public int getAge(){
        return 25;
    }
    public String getName(){
        return "zhangxueyou";
    }
}
class SonDemoB extends ObjectDemo{
    public int getAge(){
        return 18;
    }
    public String getName(){
        return "zhangyusheng";
    }
}

类

1、类的定义

在现实世界中，类是对任何事物抽象的描述。
在软件中，类是一组具有相同属性和行为的对象的抽象。
class：类：抽象：世间对一个抽象事物的描述，是一个抽象的概念，没有具体化
Ojbect：对象：实体：世间看得见摸得着的一个具体的东西

2、类的格式

[类修饰符] class 类名 {
类的成员；
}

<1>修饰符一般为public
<2>类名的首字母要大写
<3>类的成员：
包括成员变量（属性）；
方法，包括构造方法；
嵌套类。
<4>通过“ . ” 调用方法和属性；
"."导航符：通过导航符可以访问 该事物内部的信息
<5>面向对象的编程方式：
(1)描述
(2)将该事物具体化 [ 实例化 ：将刚刚描述好的事物，创建出一个真实存在的东西出来。]
(3)使用

public class Woman {
    //一个事物会有各种各样的特征，属性
    //声明四个属性
    String name;        //属性
    int age;
    int height;
    int weight;

    //构造方法：在创建对象时，可以通过该方法直接给该对象的属性赋值
    // 在new对象时，系统会自动执行该方法

    public Woman(String name, int age, int height, int weight) {
        super();
        //this:当前的---程序在当时的时间段中表示的那个对象
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }
    
    //面向对象用 方法 去描述 一个事物的行为
    public void eating() {           //方法
        System.out.println(name+"正在吃零食");
    }
    public void runing() {
        System.out.println(name+"增在跑步锻炼");
    }
}

//测试类
public class WomanTest {
    public static void main(String[] args) {
        //实例化：将刚刚描述好的事物，创建出一个真实存在的东西出来
        //实例化就是由虚转实
        Woman woman = new Woman("莉莉", 23, 170, 110);
        System.out.println(woman);
        woman.eating();
        woman.runing();
    }
}

3、类的成员

包括成员变量（属性）；
方法，包括构造方法；
嵌套类。

（1）成员变量（属性）
[ 修饰符 ] 类型 属性名；
修饰符有public、protected、default（默认）、private

（2）方法，包括构造方法；
[ 修饰符 ] 返回值数据类型 方法名（参数列表）{ 方法体； }

<1>参数列表：在方法被调用时用于接受外部传入的变量
<2>返回值数据类型：方法要返回的结果的数据类型
<3>根据有无参数可以分为有参方法和无参方法
<4>根据返回值数据类型可以分为有返回值的方法和无返回值的方法（void）
<5>方法只有在被调用时才生效
<6>使用方法时应注意：
方法定义，不能写在 main() 中；
return 只能返回一次。遇到 return 语句时，方法结束执行，后续语句不再执行；
方法的返回值类型，必须与方法声明中的返回值数据类型一致；
方法是不能嵌套的；

4、访问权限修饰符

Java有四个作用域，访问权限修饰符 -----适用于类和属性
（1）public（公有）-----任何位置都可以访问
（2）protected（受保护的）-----在同一个包中的所有类都可以访问，以及该类的子类（可以是不同包）
（3）default（默认的）-----在同一个包中
（4）private（私有的）-----只能在本类中

方法重载 - Overload

方法的重载就是在同一个类中允许同时存在一个以上的同名的方法。
（1）规则——同名不同参
<1>方法名称相同
<2>参数的个数不同
<3>参数的数据类型不同
<4>参数列表的参数顺序不同(参数列表中的参数的数据类型不同时的不同顺序)
<5>返回值不是重载的标准

//方法的重载  overload

int per(int a){
    int per = a*4;
    return per;
}
int per(int a,int b){
    int per = (a + b) * 2;
    return per;
}
double per(double r) {
    double per = r * 2 *3.14;
    return per;
}
    
//  3、参数列表的参数顺序不同(参数列表中的参数的数
//  void per(int a,String b){}
//  void per(String a,int b){}
    
public static void main(String[] args) {
    Overload perTest = new Overload();
    int a = perTest.per(5);
    System.out.println("正方形的周长是："+ a);
    System.out.println("长方形的周长是："+perTest.per(3,4));
    System.out.println("圆的周长是："+perTest.per(2.0));
}
//======================================================

public class OverloadDemo {

    //方法重载：overload
    public void a(){
        System.out.println("没有...");
    }
    public int a(int x){
        System.out.println("int...");
        return x;
    }
    public void a(String x){
        System.out.println("String...");
    }
    public void a(int x,int y){
        System.out.println("int...int...");
    }
    public void a(int x,String y){
        System.out.println("int...string...");
    }
    public void a(String x,int y){
        System.out.println("string...int...");
    }
}

对象

对象：现实世界中，看得见摸得着的，具体存在的事物。对象是系统中用来描述客观事物的一个实体。
<1>对象是构成世界的一个独立单位。
<2>具有自己的静态结构（属性）和动态方法（行为）。
<3>每个对象有自己的唯一标识。

1、类与对象的关系

类是对象的抽象，对象是类的一个实例。抽象和具体的关系。

2、创建对象的语法格式

类名 引用名 = new 构造器；

Employee    Jack  =  new   Employee();

3、构造器 — 构造方法

（1）构造器 — 又叫构造方法：
<1>具有与类相同的名称
<2>不含返回值数据类型
<3>方法体中没有return返回值
<4>一般访问权限是public

（2）作用
<1>完成对象的创建，即完成对象的实例化。在创建对象时，可以通过该方法直接给该对象的属性赋值。
<2>一般使用构造器来完成对成员变量的初始化。

（3）规则

<1>在继承时，当程序创建一个子类时，系统会先调用父类对应的构造方法， 然后再调用子类的构造方法
<2>在new对象时，系统会自动执行该方法
<3>在继承时，子类不能够继承父类的构造方法
<4>一般创建一个描述class ，系统会自动给该class添加一个无参构造方法，若认为给当前class添加有参构造方法，则必须手动添加无参构造方法，系统不会自动添加

public class Father {

    String name;
    int age;
    int money;
//有参构造方法
    public Father(String name,int age,int money){
        super();
        this.name = name;
        this.age = age;
        this.money = money;
    }
//无参构造方法
    public Father(){
        System.out.println("new Father...");
    }   
}

this关键字

this：当前的---程序在当时的时间段中表示的那个对象
（1）代表对象自身的引用：一个指向调用该方法的当前对象的引用，通常在类的方法的定义中使用。

（2）使用情况
<1>方法中的变量要与参数列表中的变量相同
<2>在构造器中，调用其他重载的构造器
<3>返回当前对象的引用

public class Animal {

    String name;
    int age;    
    public Animal(String name,int age){
        super();
        this.name = name;
        this.age = age;
    }
}

static关键字

——static：静态：可以作用到属性上，也可以作用到方法上 。
——static：可以修饰 属性，方法，代码块。

（1）属性或方法上面有static关键字修饰，则该属性或方法属于class级别，可以被所有对象共用，可以直接通过“class.”访问。

（2）static的属性和方法，在程序加载的过程中，优先级高于非静态属性和方法。

（3）静态的方法中，只能够使用静态的属性，调用静态的方法；
非静态的方法也可以使用静态属性，可以调用静态方法。

（4）static 只能修饰类成员，不能修饰局部变量。

public class Student {
    String name;
    int age;
    static int count;//
    public Student(){
        System.out.println("aaaaa");
        count=count+1;
    }   
}

public class StudentTest {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();   
        System.out.println(student1.count);
        System.out.println(student2.count); 
        Student student3 = new Student();
        System.out.println(student3.count);
        System.out.println(student3.name);      
        
        System.out.println(Student.count);
    }
}

1、静态变量

（1）也叫做类变量，所有对象都可以使用。

（2）用 static 修饰的成员变量，它们在类被载入时创建，只要该类存在，static 变量就存在，就可以被使用。

（3）static 变量有两种访问方式：
—— 直接访问： 类名 . 属性
—— 实例化后访问： 对象的引用 . 属性

2、静态方法

（1）也称为 类方法，不需要实例化，可以直接访问。

（2）静态方法 两种访问方式：
—— 直接访问： 类名 . 方法名（）
—— 实例化后访问： 对象的引用 . 方法名（）

（3）静态方法的作用：
—— 简化方法的使用；
—— 便于访问静态属性；

（4）注意事项
—— 静态方法里只能够直接访问静态成员，而不能够直接访问类中的非静态成员。
—— 静态方法中不能使用this、super 关键字。
—— 静态方法不能够被非静态方法覆盖（重写），静态方法不能够修饰构造器。

public class Temp {
    static int a;
    int b;
    int c;  
    public static void a(){
        System.out.println(a);
        //System.out.println(b);//错误，不能够访问非静态属性
        //System.out.println(c);
        //b();错误，不能够访问非静态方法
        //c();
    }
    public void b(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
    public void c(){
        a();
        b();
    }   
}
//测试类
public class TempTest {
    public static void main(String[] args) {
        //因为a方法为静态方法，属于class级别，可以直接通过class访问
        Temp.a();
        //a属性为静态属性，属于class级别，可以直接class访问
        System.out.println(Temp.a);
        
        Temp t1 = new Temp();
        //b、c方法为非静态方法，只能够通过创建对象后访问
        t1.b();
        t1.c();
    }
}

3、静态代码块

—— static修饰的代码块：一个类中由 static 关键字修饰的，不包含在任何方法体中的代码块。
（1）当类被载入时，静态代码块被执行，且只能被执行一次；
（2）静态代码块经常用来进行类属性的初始化；

public class StaticTest {

    //静态代码块：在整个系统操作期间只运行一次
    //读取该软件的系统配置信息，一般创建一个即可
    static{
        System.out.println("静态代码块");
    }

    //代码块：在主程序加载完后，子程序的初始过程
    {
        System.out.println("代码块1");
    }
    {
        System.out.println("代码块2");
    }
    
    //构造方法：子程序的构造过程 ----- 一般将代码块写在构造方法中
    public StaticTest(){
        System.out.println("构造方法");
    }
    
    //普通方法
    public void run(){
        System.out.println("普通方法");
    }
    
    
    public static void main(String[] args) {
        StaticTest test1 = new StaticTest();
        //如果想要运行普通方法，需要调用该方法
        //test1.run();
        StaticTest test2 = new StaticTest();
        StaticTest test3 = new StaticTest();
    
    }
}

变量的作用域

Java中一个类里面包含三种变量：
1、类变量
—— 用static 关键字修饰的成员变量，它们在类被载入时创建，只要类存在，static 变量就存在。
—— 常驻内存，不会被回收，系统运行时使用。
2、实例变量
—— 类体中声明的成员变量成为全局变量；
—— 全局变量在整个类的生命周期中都可以使用。
3、局部变量
—— 在方法体中声明的变量，方法中的参数，或代码块中声明的变量，都是局部变量；
—— 局部变量只在方法调用的过程中有效，方法调用结束后失效；

public class Empolyee {

    static String name; //静态变量      |
    int age;            //实例变量      |—— 全局变量
    double salary;      //实例变量      |
    
    public String sayHello(){
        String hello = "你好";   //局部变量
        System.out.println(hello+name);
        return name;
    }
}