面向对象和对象的区别

JAVA面向对象和对象的区别

类是对对象的一个抽象
类是抽象一个模板或者说是一个图纸

抽象一个模板，根据这个模板想象需要什么
属性也可以叫成员变量，方法|功能(动作)构造器无参构造和有参构造

 // 这个例子就是封装，  属性私有化，提供set/get方法
 public class Person{
Private String name;
Private int age;
//    private String sex;
 private boolean gender;

//无参构造器
public Person(){
}
//带参构造器
public Preson(String name, int age,  boolean gender) {
this.name = name;
 this.age = age;
 this.gender = gender;

//下面提供set/get方法
  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;
    }
//如果是boolean类型， 请使用 is+属性名首字母大写
 public boolean isGender() {
        return gender;
    }
//共有的功能也可以叫方法
 public void setGender(boolean gender) {
        this.gender = gender;
    }
    public void   eat(){
        System.out.println("会吃饭");
    }
}

对象是类的具体实物，或者说是实例化类的抽象的事物
下面例子叫做对象
对象就是具体实现的

public class TestPeson{
	public static void main(String[] args) {
      Preson p = new  Preson();
      Student s = new Student("张三",18,true,"001","初级");
      System.out.println(s.getName()+s.getAge()+s.isGender()+s.getId()+s.getGrade());
      
      }
}

封装
关键字：
public（公共的）修饰词，表示成员是公开的,所有其他类都可以访问
private（私有的）修饰词，表示成员是私有的,只有自身可以访问。
protected（受保护权限）修饰的方法属性，在统一包下的类都可以访问调用
default （默认的）其他包访问不到该类 导包也不行
javaBean的规范，属性私有化，无参构造器和有参构造器，提供 set|get方法

构造器可以叫构造方法也可叫构造函数

方法名必须和类名一致（和当前类名一致）不能添加任何的返回值类型 连void 都没有
每一个类中都一定存在至少一个构造器（如果没给，系统给，无参的空构造，如果给了，系统将不再提供任何构造器）
只要看到new 创建对象 系统一定会调用构造器，而且只能系统调用
构造器用作属性的初始化，初始化只是借助构造器一定在创建对象时会调用的这个特点，里面的实现还得自己来
当局部变量（形式参数）和属性同名的时候，需要通过this区分

创建对象的过程：
1.根据模板在堆中开辟一块空间
2.调用构造器初始化属性
3.返回空间的首地址

权限修饰符

关键字
private 同一个类
default 同一个类 同一个包中
protected 同一个类 同一个包中 子类
public 所有类
白话：该漏的漏 该藏得藏
专业：我们程序设计要追求 高类聚 低耦合
高类聚：就是类的内部数据操作细节 自己完成不允许外部干涉
低耦合：仅暴露少量的方法给外部使用

编程中封装的具体意义:
便于调用者调用
良好的封装 便于修改内部代码 提高可维护性
良好的封装，可进行数据完整性检测，保证数据的有效性。
9.2. 使用访问控制符，实现封装

代码块
普通块：方法中 随着方法的调用而执行
构造块：类体中 方法外 每一次创建对象随着构造器执行（构造器之前）
静态块：类体中 方法外 被static修饰 类加载的时候执行 类只会加载一次

继承
第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性。（事实上，利用组合可以更好的实现代码复 用！）就是子类继承父类之后子类就可以拥有父类的一切内容，（除了构造器）但是子类在创建对象的时候会默认调用父类的构造器在入口的第一行。
关键字；extends （继承）
继承创建对象的顺序是；先父类，在找子类；
java里面 继承 只能单继承。
下面是语法格式；

public class 子类类名 extends 父类 类名{
    
}

//子类
//子类继承父类 如果在创建对象的时候会默认调用父类构造器有参数就给实参没有就不用。
public class S extends F{      
  public  S(){
  		super(1);
        System.out.println("我是构造器");
        System.out.println("S");
    }
}

/**
 * 父类
 */
public class F{
    public int b;
    //父类只提供了有参构造器 在创建子类对象的时候 子类就要给父类的构造器传入实参否则报错
    public F(int a){
        System.out.println("F");
    }
}

this关键字
this 是指当前类的当前对象
可以自己调用自己的属性 方法和构造器 但是不能用父类的
this: 当前类的当前对象
this.自己的属性
this.方法()
this()

语法格式；

this.自己当前的类的属性
this.自己当前方法
this.自己的构造器；
/*
学号
所在班级
学习
学生是一个人
*/
public class Student extends Person{
    // 直接从父类继承下来的内容
    // 需要有自己的特性
    private String sid;
    private String sclass;
public void study(){
        System.out.println("你现在应该好好学习，不配。。。");
    }

 public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        就近原则。加上this.属性 寻找当前这个对象的成员属性
        this.sid = sid;
    }
      public String getSclass() {
        return sclass;
    }
      public void setSclass(String sclass) {
        this.sclass = sclass;
    }
}

super关键字

super 是直接父类对象的引用 可以通过 super来访问父类中被子类覆盖的方法 或属性
普通方法：
没有顺序限制 可以随便调用

创建子类对象的时候一定会先创建父类对象（这是一个递归的过程）直到Object
super
访问父类的属性：super.属性名；前提是有访问权限
方法父类的方法：super.方法名();前提是有访问权限
访问父类的构造器： suepr(); 前提是有访问权限
访问构造器的特点：
第一行，构造器中，不能形成闭合的环。在没有显示通过super调用父类构造器 时，一定会在子类构造器的入口默认调用一个无参构造 suepr() , 如果父类中没有 提供无参构造，子类必须手动调用父类的带参构造 suepr(实参列表);super:当前类的父类对象

super.父类的属性
super.父类的方法
super()；

跟this 是一个道理 不能调用子类的特有属性和方法。

static关键字

属性：先于对象存在，跟随类存在，所以可以直接通过类名访问；所有对象共享一份
方法：先于对象存在，跟随类存在，所以可以直接通过类名访问； 静态方法中只能访问静态内容
用static声明的方法为静态方法
不需要对象，就可以调用( 类名.方法名() ) 在调用该方法时，不会将对象的引用传递给它，所以在static方法中不 可访问非 static的成员。也不可以出现this关键字
可以通过对象引用或类名（不需要实例化）访问静态成员。