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,"金毛");
}
}
/*补充:当执行子类中的构造方法时,会先跳到子类的构造方法位置,但并不执行,若此时该构造方法中指明了指向
哪个构造方法则跳到对应的构造方法后再回来执行,若未指明则默认为跳到无参的父类构造方法再跳回(其实父类的构造方法中
也会有类似的操作)*/