java的方法重载，面向对象的概念，编写类以及创建对象，成员变量与局部变量的区别，构造方法以及构造方法的重载，空指针异常，封装，this关键字，参数传递，static关键字，继承的概念及相关代码

方法重载

理解定义：在同一个类中，方法的名字相同，参数列表必须不同,与返回值类型无关，称为方法的重载。
简单举个例子

//部分代码
public class 方法重载{
 public void show(){
 .......................
 }
 public void show(int a){
 .......................
 }
 public double show(int a，int b){
 ........................
 }
 public static void main(String[] args){
 ........................
 }
}

由例子可见三个方法个名字相同，但返回类型有相同有不同，最重要的是参数全不相同，这就是方法重载。

面向对象概念

概念：
—面向对象：虚拟世界"模拟现实"生活,必须保证模拟一致
—类:对同一类事物的抽象描述，也就是不是具体的
如：电脑类、杯子类、汽车类、人类…
—对象：万物皆对象，也就是具体的实例
如：我的水杯、张三的车
—类与对象关系：抽象与具体的关系
描述对象的特征，称为属性
对象所做的事情，称为方法(行为、动作)

编写类以及创建对象

class Student{ //编写类
//对象的属性，或称为成员变量，实例变量
      String name;
      int age;
      char sex;
      boolean p;
//对象的方法，也称成员方法或实例方法
public void print(){          
    System.out.println("Helloworld");
    }
}//到此类编写完成

public class 创建对象{
//对象创建在类中
public static void main(String[] args){
    Student temp=new Student();//创建对象也叫实例化
    对对象赋值
    temp.name="李四";
    temp.age=12;
    temp.sex='男';
    System.out.println("姓名"+temp.name+"\n年龄"+ temp.age+"\n性别"+ temp.sex+"\n"+temp.p);
   }
}

成员变量和局部变量区别

成员变量和局部变量区别
----声明位置不同
成员变量：在类中声明
局部变量：在方法中声明,形参也属于局部变量
----初始值不同
成员变量：当没有对成员变量赋值时有默认值，类型不同默认值不同，具体如下
1.整数类型默认值为0
2.浮点类型默认值为0.0
3.字符类型默认值为\u0000（输出为空格）
4.布尔类型默认值为false
5.所有引用数据类型默认值为null（例如String和自定义类名）
局部变量：没有初始值，也就是说：必须先声明，然后再赋值，最后才可以使用。
成员变量可以与局部变量同名，但是局部变量优先，如果非要访问成员变量则必须添加this.
this代表当前这个对象，也就说当前谁调用该方法这个对象就是谁

构造方法以及构造方法的重载

作用：对属性赋值的
理解定义：构造方法是一个特殊的方法，构造方法的名字必须与类名一致，构造方法必须没有返回值类型，也就是不编写（void也不写）

//部分代码
class Dog{
		//无参构造方法
		public Dog(){
		
		}
		//有参的构造方法
		public Dog(int a){
		...................
		}
}

构造方法如何执行的？
----当创建对象的同时执行相匹配的构造方法（要看参数所对应的）
构造方法的分类
----隐式构造方法
当在一个类中，没有手动编写构造方法，则系统会提供一个默认的无参的构造方法
----显式构造方法
当在一个类中，手动编写构造方法，则系统不会提供默认的无参的构造方法
建议：当手动编写构造方法之前，先编写无参的构造方法，然后再编写需要的构造方法（如果不写无参的构造方法则会报错）
2.5构造方法重载
在同一个类中，构造方法名字必须相同，参数列表必须不同
(与普通方法重载的区别是构造方法没有返回值类型)

空指针异常

原因：当引用名称的值为null时，就不能访问对象中的属性和方法。（否则就会出现空指针异常）
解决办法：在访问实例属性和方法之前，必须保证引用名称的值为某个对象的地址。
举例:

班级类
class Grade{
//无参构造函数
  public Grade(){

  }
//有参构造函数
public Grade(String name,String local){
    this.name=name;
    this.local=local;
}
String name;
int num;
String local;
}

//学生类
class Student1 {
//无参构造方法
public Student1(){

}   
//有参数构造方法
public Student1(String name,String sex,int age,Grade grade){
//Grade为用户自定义类型，是一种引用类型，该类型变量存储的是地址
    this.name=name;
    this.sex=sex;
    this.age=age;
    this.grade=grade;//参数传过来的是地址
 }
String name;
String sex;
int age;
Grade grade=new Grade();***//此时一定要给grade赋值，否则系统默认为null,下面若调用此对象中的东西就会显示空指针异常***


public void show(){
    System.out.println("学生姓名:"+name+"\n性别"+sex+"\n年龄"+age+"\n班级名称:"+grade.name+"\n班级位置:"+grade.local);
   }
}

public class 空指针异常{
public static void main(String[] args) {
    Student1 student=new Student1("张三","男的",12,new Grade("五班","三楼"));//注意此时给Grade变量赋值时用的是new Grade("五班","三楼")，这与其他类型区别很大
    }
}

封装

封装：隐藏类的内部信息，不允许外部程序直接访问，而是通过方法进行操作。
封装的操作步骤：
第一步：将属性设置为私有的private,也就是只能在本类中进行访问
例如：
private int age;
第二步：编写对应属性的方法(赋值方法、取值方法)

举例：

class Student2{
//private作用为将属性设置为私有的private,也就是只能在本类中   进行访问
private int age;
private String name;
private char sex;
//赋值方法
public void setAge(int age) {
    if (age > 0 && age < 120) {
    //加入判断也可不加判断，根据题目要求进行判断，个人感觉这是封装的精髓
        this.age = age;
    } else {
        this.age = 0;
    }
}
public void setName(String name){
    this.name=name;
}
public void setSex(char sex){
    if(sex=='男'||sex=='女') {
        this.sex = sex;
    }
    else{
        this.sex='女';
    }
}
//从赋值方法可以看出赋值方法的返回值类型全为void

//取值方法
public int getAge(){
    return age;
}
public String getName(){
    return name;
}
public char getSex(){
    return sex;
}
//从取值方法可以看出取值方法是利用return语句进行取值

}
public class 封装 {
public static void main(String[] args) {
    Student2 student=new Student2();
    student.setAge(12);
    student.setName("张三");
    student.setSex('男');
    System.out.println("年龄:"+student.getAge()+"\n名字:"+student.getName()+"\n性别:"+student.getSex());
  }
}

this关键字

this关键字:代表当前这个对象，也就是说当前谁调用该方法则这个对象就是谁
----this关键字可以访问本类中的属性
当局部变量和成员变量没有同名时，则：this.name 等价于 name
当局部变量与成员变量同名时，局部变量优先，如果非要访问成员变量则必须使用this.
----this关键字可以访问本类中的方法
this.show3(); //等价于 show3();
----this关键字还可以访问本类中的构造方法，this([参数列表]);（这点值得注意）
注意：1.当访问本类的其他构造方法时，则必须编写在构造方法中，并且是第一条语句
2.当访问本类中的实例属性和实例方法时(属性没有与局部变量同名的)，默认前面有this.

参数传递

----基本数据类型作为参数传递，传递的是真正的值
----引用数据类型作为参数传递，传递的是地址(引用)

static关键字

----static关键字可以修饰属性，该属性在方法区(共享区)中存储，并且所有对象都可以访问
与类同生死，静态属性或类的属性（类在则在）
在访问时，引用名称.属性名称 或 类名.属性名称
注意：当引用名称的值为null时，也可以访问静态属性
类优先于对象，类的生命周期比较长
----好处：节省空间
----static关键字可以修饰代码块，称为静态代码块
完成对类的属性(静态属性)赋值
当类第一次被载入时静态代码块就被执行
----static关键字还可以修饰方法，称为静态方法或类的方法
注意：静态方法中只能访问静态变量和方法（这点比较重要）
举例：

class Student4{ 
//静态代码块 为类的属性赋值
static{
    age=19;   //静态代码块自动执行，且只在第一次载入类时执行
    System.out.println("执行了静态代码块");
}
public Student4(){

    }
public Student4(String name,char sex){
    this.name=name;
    this.sex=sex;
    System.out.println("执行了非静态代码块");
}

//此方法为类的方法，类在则此方法在
public static void show1(){
    System.out.println("执行了类的方法");
}
public void show2(){
    System.out.println("执行了实例方法");
}
static int age;/*定义了类的属性; 当属性为类的属性时，此属性不再为对象的属性，但可在对象中调用，
这样做可以节省很多空间，不用在每次创建对象时再开辟一块空间(但这样只适合所有对象中该属性的值都是相同的)*/
String name;
char sex;
}

public class static关键字 {
public static void main(String[] args) {

    System.out.println(Student4.age);//在此之前还执行了静态代码块中的内容
    Student4.show1();
    System.out.println();//空行区分
    Student4 student=new Student4("李四",'男');
    System.out.println("年龄："+student.age+"\n姓名："+student.name+"\n性别："+student.sex);
   
   }
}

继承

继承好处：减少代码的冗余性
编写继承的代码步骤：
1.编写父类
2.编写子类
继承中的注意事项：
—子类继承父类，不能继承父类的构造方法（这点重要）
—父类(超类或基类)
子类(派生类)
—继承特性：
在Java中一个类只能继承一个直接的父类，也就是说类是单根性
类具有传递性
举例：

编写父类
class Animal{//该行等价于class Animal extends Object{}，Object为一个系统类
String sex;
int age;
public Animal(){
    System.out.println("执行了父类中的无参构造方法");//若未指明指向哪个父类构造方法，则执行该语句
}
public Animal(String sex,int age){
    System.out.println("执行了父类中的有参构造方法");
    this.sex=sex;
    this.age=age;
}

public void show(){
    System.out.println("性别："+sex+"\n年龄："+age);
    }
}

编写子类
class Dog1 extends Animal{
String strain;
public Dog1(){
    System.out.println("执行了子类的无参");
}
public Dog1 (String sex,int age,String strain){
   /* this.sex=sex;
      this.age=age;
      this.strain=strain;
      System.out.println("性别"+sex+"\n年龄"+age+"\n品种"+strain);方法一*/
   /* super.sex=sex; this现在子类中找，若未找到再去父类中寻找，而super直接去父类中查找
      super.age=age;
      this.strain=strain;
      System.out.println("性别"+sex+"\n年龄"+age+"\n品种"+strain);方法二*/
      super(sex,age);
      this.strain=strain;//注意此时不可为super.strain=strain，因为strain实在子类中定义的
      super.show();//或者为this.show();
      System.out.println("品种："+strain);//并在父类中建造对应的构造方法  方法三
    } 
}

public class 继承 {
public static void main(String[] args) {
    Dog1 dog=new Dog1("男",12,"金毛");
    }
}
/*补充：当执行子类中的构造方法时，会先跳到子类的构造方法位置，但并不执行，若此时该构造方法中指明了指向
 哪个构造方法则跳到对应的构造方法后再回来执行，若未指明则默认为跳到无参的父类构造方法再跳回（其实父类的构造方法中
也会有类似的操作）*/