面向对象1---this、构造方法、方法重载，静态，权限、getter和sett、继承、super、方法重写、多态

面向对象

1、类与对象

面向对象：

• 类：就是图纸

  属性：这一类的共同属性
  动作方法：这一类事务共同能执行的功能

• 对象使用类创建的某一个东西

  对象能干什么，完全于类是如何定义的

• 写代码
  类要使用class来定义

public class Car {		
}

属性：用成员变量来描述，直接写在类中的变量

public class Car {
    String color; //颜色
    int speed;//

写在方法里的变量，局部变量

public class Car {
    String color; //颜色
    int speed;//速度
        public static void main(String[] args) {
        //写在 方法里的变量，局部变量
        int a = 10; 

动作：成员方法，不写static就是成员方法

public class Car {
    String color; //颜色
    int speed;//
   // 动作，成员方法
        public void run(){
          System.out.println("车能跑");
    }

1. main方法是程序运行的入口
2. 面向对象里变量被称为引用，java的两种数据类型：1、基本数据类型/2、引用数据类型这里就是Car类，可以由自己定义这个类
3. 建立一个对象车，通过实例化的c来调用方法动作

2、this关键字

this在调用方法的时候，java会自动把创建的对象，传递给方法，在方法中由this来接收对象，this也就是调用成员变量的属性
this在类的方法中获取对象中的属性信息
this也可以区分成员变量和局部变量，如果局部变量与成员变量有同名的变量，用this 点 来调用成员变量的变量

3、构造方法

在创建对象时，自动调用的方法
语法：
public 类名（传参）{
}；
注意：
1、构造方法没有返回值
2、我们在new 类名（）；的时候，自动调用构造方法 类名() 就是构造方法

public class Car {
    String color; //颜色
    int speed;//

构造方法语法：  public Car（ String color，int speed）{//传参
				//设置属性信息
				this.color = color;
				this.speed == speed;
}

作用：在创建对象的时候，给对象设置属性信息

4、构造方法重载

5、static静态

static 修饰类中的属性
static的内容会在内容中保留一份，并且供对象修改后也会共享修改内容，
对象中 修改语法：
类名 .属性=“修改内容”
Person.country = “民国”；

static修饰属性
特点：
1、数据共享
2、属于类的，不属于对象
3、优先于对象产生

6、访问权限

1、public 公共点，所以人都可以访问，在包内或别的包都可以访问
2、defaulf 包访问权限。仅限在自己的包里随意访问
3、private 私有的

7、getter和setter

成员变量在使用private来声明时，保护成员变量不被乱赋值时使用 getter和setter
setter：主要是给成员变量赋值，做一定的保护
getter：从成员变量中获取数据

getter和setter自动生成：
空白位置->单机右键->generate自动生成->getter and setter -> 全选 ->ok

getter和setter自动生成

8、 继承

关键字：继承 extends
子类可以拥有父类的所有内容，私有内容除外，私有的内容是不可以继承的
当A属于字母的时候可以生成继承关系
语法：
public class 子类 extends 父类{
}
作用：
简化代码开发

//父类
	public class Yaoguai{
		public void eat(){
			System.out.println("妖怪吃人")
	}	//私有的
		private void pasi(){
			System.out.println("妖怪怕死")
	}
---------------------------------------------
//子类：继承黑熊精属于妖怪
public class Heixiongjing extends Yaoguai{
}
---------------------------------------------
//测试
public class Test{
		public static void main(String [] args){
			Heixiongjing hei =new Heixiongjing();
		    hei.eat;//子类没有赋值可以调到父类中的方法
		    //hei.pasi  私有的是钓调不到的
}		

9、super关键字

1、super代表父类中的内容
2、This 代表自己类中的内容
3、super 或 This 可以区分父类和子类中的重名内容
4、在创建对象时，先创建父类的对象然后再创建子类的对象
5、super可以调用父类中的构造方法，必须写在子类构造方法的第一行，如果父类的构造方法无参数，可以不写，如果有参数的构造，必须写super

要先创建父类构造方法

子类构造方法

super可以调用父类中的构造方法，必须写在子类构造方法的第一行，如果父类的构造方法无参数，可以不写，如果有参数的构造，必须写super；

10、方法的重写

重写：子类对父类中提供的方法进行重新定义
语法：
子类和父类的方法的声明完全一致

	super.方法 这里可以调用父类的方法.

父类方法：
public class Dongwu {

    public void eat(){
        System.out.println("父类方法：吃东西");
    };
}
----------------------------------------------------------
子类方法重写：
public class Cat extends Dongwu {
    @Override
    public void eat(){
		super.eat(); super这里也可以调用父类的方法
        System.out.println("子类重写；猫吃鱼");
    }
}
-----------------------------------------------------------
测试：
public class DongwuTest {
    @Test
    public  void Test(){
    //创建一个猫调用猫的方法
        Dongwu cat=new Cat() ;
        cat.eat();
    }
}
运行：
父类方法：吃东西//super.调用的父类方法
子类重写；猫吃鱼//子类覆盖的方法

11、多态

同一个对象拥有多种形态
作用：把不同的数据类型进行统一
把子类的对象赋值给父类的变量->向上转型
把父类的变量转化回子类的变量->向下转型必须写强制类型转换（转换之后的数据类型）变量

子类方法
public class Cat extends Dongwu {//子类继承父类的方法
    @Override
    public void eat(){

        System.out.println("子类重写；猫吃鱼");
    }
}
--------------------------------------------------------
测试：
public class DongwuTest {
    @Test
    public  void Test(){
        Dongwu cat=new Cat() ;//把猫当成动物来看，把子类的对象赋值给父类的引用（变量）向上转型
        cat.eat();

把子类的对象赋值给父类的变量->向上转型
把父类的变量转化回子类的变量->向下转型必须写强制类型转换（转换之后的数据类型）变量