JAVA面向对象、类和对象定义及使用、封装、继承

private String name;
private int age;
private double height;

定义变量参数中有：属性，变量，存储数据构造方法

构造方法：用来初始化对象(构造方法是用来创建对象的）

语法：访问修饰符   类名（参数列表...）{ .....};

无参构造方法：

public Student(){

System.out.println("无参的构造方法被调用")；
}

有参构造方法：

 public Student(String name, int age, double weight) {
        Name = name;
        Age = age;
        Weight = weight;
    }

get方法和set方法： 

 public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    public double getWeight() {
        return Weight;
    }

    public void setWeight(double weight) {
        Weight = weight;
    }

toString方法（方便打印类）：

@Override
    public String toString() {
        return "Student{" +
                "Name='" + Name + '\'' +
                ", Age=" + Age +
                ", Weight=" + Weight +
                '}';
    }

类区别：

标准的类：属性（变量）,无参构造方法，有参数构造方法，针对属性get和set方法，成员方法（功能），toString（方便打印类）；

有的类更多的是定义属性和get及set方法，一般用来储存数据和操作数据；

有的类更多的是定义的是方法，是用来提供功能的，

对象：

对象的产生：

类名称 对象名称 = new 类名称();

以Person类为例，可以产生一个Person类的实例（对象）：

       Student stu1 = new Student();无参数person
       Student stu2 = new Studnet("张三", 12); 有参数Student

通过对象调用实例变量与实例方法：

只要new就代表开辟了一个内存

        Student stu = new Studnet("张三", 18);
        System.out.println(stu.name);
        System.out.println(stu.getPersonInfo());

对象的栈和堆：

1. 栈：存放的是局部变量，Java栈是与线程对应起来的，每当创建一个线程，JVM就会为这个线程创建一个对应的Java栈。
2. 堆：保存的是真正的数据，即对象的属性信息。

封装 

类：定义变量和方法

定义变量：存储数据的

定义方法：完成功能

封装的定义：把属性私有化，实现了对外界的隐藏，然后通过共有的getter和setter方法对属性进行获取和赋值，保证了操作的安全性。

一般属性私有化（private），方法公有化（public），除非方法只有用来内部调用，可以private修饰。

1.对属性使用private私有化进行修饰，实现了对外界的隐藏，外界不能够直接操作类的属性

2.定义针对属性的getter和setter方法，完成对属性的获取和设置值，再发放中可以完成完全认证验证；

注意：

属性私有化后也可以通过有参数的构造方法进行赋值，且在有参构造方法中进行安全验证。

Java的封装作用
1.提高了程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增强系统的可维护性

package Fengzhuang;
   //类    private：私有
public class student {
       //属性私有
       private String name; //名字(属性)
       private int id; //学号（属性）
       private char sex;//性别（属性）
       private int age;  //年龄（属性）


       //学习（）      这是方法
       //性别（）      这是方法
       //提供一些可以操作这些属性的方法
       //提供了一些public的get  ,set方法
       //get   获取这个数据
       public String getName() {
           return this.name;
       }

       //set   给这个数据设置值
       public void setName(String name) {
           this.name = name;
       }

       //alt+insert

       public int getId() {
           return id;
       }

       public void setId(int id) {      
           this.id = id;
       }

       public char getSex() {
           return sex;
       }

       public void setSex(char sex) {
           this.sex = sex;
       }

       public int getAge() {
           return age;
       }

       public void setAge(int age) {
           if (age > 120 || age < 0) {//判断年龄乱写不叫打印
               this.age = 3;
           }
       }
   }

继承：

继承是子类继承父类的特征和行为，使得子类对象具有父类的实例域和方法，子类从父类继承方法，使得子类具有父类相同的行为。

继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系

class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

继承的目的和效果是什么：

1.子类继承父类，父类定义的公共的属性和方法子类会拥有，但是子类定义的私有化的属性和方法，子类不能继承；

2，父类继承过来的方法，子类可以进行改造，重新实现功能（方法的重写），调用的时候执行的是子类新实现的方法

 super 与 this 关键字：

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

//子类
public class men extends People{
    public men(){
        //super();
    }
    public men(String name){
//当使用this时，super自动消失，因此必须放在第一行
        this(name,18)//18是在创建对象时补充的值
    }
    public men(String name,int age){
        //super();
        this.name = name;
        this.age = age;
    }
}
 public static void main(String[] args){
    men man1 = new men("哈哈");
}

方法的重写

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

父类方法中的功能无法满足子类的要求，所以对父类中的方法进行重写。

//父类
public class People{
    public void say(){
        System.out.println("Hello World！");
    }
}
    
//子类
public class men extends People{
    public void say(){
        Student stu=new Student()
        stu.say();
        System.out.println("我能把Java学好吗？");
    }
}
输出结果为：
Hello World！
我能把Java学好吗？

另外在重写方法时@Override可以用来重写注解，其好处是：

@override是放在重写后的方法上，作为重写是否正确的校验注解
加上该注解后如果重写错误，编译阶段会出现错误提示
建议重写方法都加@override注解，代码安全

方法重写注意事项、要求

重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
私有方法不能被重写。 
子类不能重写父类的静态方法，如果重写会报错的