Day09 JavaSE

今日重点:类,对象,方法

一.面向过程面向对象

1.他俩都是一种对软件进行分析,设计,开发的思想.

2.面向过程思考的是:如何按照步骤实现,并将步骤对应成方法,一步一步最终完成. 微观上:执行和处理数据

3.面向对象思考的是:如何设计这个事物,宏观上:面向对象可以帮助我们从宏观上把握,从整体上分析设计整个系统

二.类和对象

1.类(class)可以看成一类对象的模板.

2.对象:我们叫做object,instance(实例),对象可以看成是该类的一个具体实例.

3.类是用于描述同一类型的对象的一个抽象概念,类中定义了这一类对象的共同属性和方法.

举个例子:月饼模具和月饼,月饼模具是一个类,使用月饼模具制作的一个个月饼就是对象

三.定义类格式

定义类:所谓类是一个抽象的概念,他是对某一类事物整体的描述和定义,并不能代表某一个具体的事物.我们可以根据具体的需求来自定义类型,java中所有的自定义类型都是引用类型.

class 类名{
数据类型 名称;
数据类型 名称;
}

四.定义实例变量(Field)

我们定义类是用于描述某一种具体事物的,这类事物一定有其特点,用来描述这些特点的内容称为实例变量.一个类中的实例变量名必须唯一.实例变量也称为属性或成员变量.

语法:
    class 类型名称{
    访问修饰符 实例变量类型 实例变量名称=[=初始化值(可写可不写)];
    }
    
演示:
package com.bjsxt.pojo;  
  
public class Demo {  
public int num1;  
public byte num2;  
public short num3;  
public long num4;  
public float num5;  
public double num6;  
public boolean num7;  
public char num8;  
public String num9;   
}
package com.bjsxt.test;  
  
import com.bjsxt.pojo.Demo;  
  
public class Test {  
public static void main(String[] args) {  
Demo demo=new Demo();  
System.out.println(demo.num1);  
System.out.println(demo.num2);  
System.out.println(demo.num3);  
System.out.println(demo.num4);  
System.out.println(demo.num5);  
System.out.println(demo.num6);  
System.out.println(demo.num7);  
System.out.println(demo.num8);  
System.out.println(demo.num9);  
  
}  
}
package com.bjsxt.pojo;  
  
public class Demo01 {  
public String str;  
public Byte num1;  
public Short num2;  
public Integer num3;  
public Long num4;  
public Float num5;  
public Double num6;  
public Boolean num7;  
public Character num8;  
}
package com.bjsxt.pojo;  
  
public class Test01 {  
public static void main(String[] args) {  
Demo01 demo01=new Demo01();  
System.out.println(demo01.num7);  
System.out.println(demo01.num1);  
System.out.println(demo01.num2);  
System.out.println(demo01.num3);  
System.out.println(demo01.num4);  
System.out.println(demo01.num5);  
System.out.println(demo01.num6);  
System.out.println(demo01.num8);  
System.out.println(demo01.str);  
;  
}  
}

五.方法定义和四种写法

语法:
访问权限修饰符 返回值类型 方法名(参数) {  
// 0 ~ N 行 Java代码 ,在这里叫做 方法体  
}  
访问权限修饰符: 支持所有的访问权限修饰符 现在用 public  
返回值类型: 方法执行完毕之后返回的数据结果类型 如果没有数据返回 就直接写成void (空 无 没有)  
方法名: 我们可以自定义 小驼峰命名  
参数: 可以有参数 也可以没有参数 根据我们的实际需要来  
定义方法时 如果使用了参数 这个参数 叫做 形式参数 (说白了 就是样子货 只有类型的默认值)

package com.bjsxt.pojo;  
  
public class Demo02 {  
//无返回值,无参数  
public void testA(){  
System.out.println("sss");  
System.out.println("sss");  
System.out.println("sss");  
System.out.println("sss");  
System.out.println("sss");  
}  
//有返回值,无参数  
public int testB(){  
int i=100;  
if(i>100){  
return 1010;  
}else{  
return 1000;  
}  
}  
//无返回值,有参数  
public void testC(int n,int m){  
int num=n m;  
System.out.println(num);  
}  
//有返回值,有参数  
public int testD(int a,int b){  
int sum=a b;  
return sum;  
}  
  
}

六.通过类的实例化调用属性,给属性赋值

package com.bjsxt.pojo;  
  
public class people {  
public String name="李四";  
public String sex;  
public long phoneNumber;  
String idCard;  
String[] aihao;  
int age;  
double money;  
}


package com.bjsxt.test;  
  
import com.bjsxt.pojo.people;  
  
public class PeopleTest {  
public static void main(String[] args) {  
//通过类的实例化调用属性,给属性赋值  
people p=new people();  
p.name="zhangsan";  
p.sex="男";  
  
System.out.println(p.name);  
  
}  
}

七.通过实例化调用方法

语法:  
  
 类名 对象名 = new 类名();  
  
 没有返回值的语法:  
 对象名.方法名();  
 对象名.方法名(具体的值);  
  
 有返回值的语法:  
 数据类型 变量名 = 对象名.方法名();  
 数据类型 变量名 = 对象名.方法名(具体的值);
package com.bjsxt.test;  
  
import com.bjsxt.pojo.Demo02;  
  
public class Test02 {  
public static void main(String[] args) {  
Demo02 demo02=new Demo02();  
demo02.testA();  
int a=demo02.testB();  
System.out.println(a);  
demo02.testC(10,20);  
int res=demo02.testD(30,40);  
System.out.println(res);  
}  
}


package com.bjsxt.pojo;  
  
public class Demo02 {  
//无返回值,无参数  
public void testA(){  
System.out.println("sss");  
System.out.println("sss");  
System.out.println("sss");  
System.out.println("sss");  
System.out.println("sss");  
}  
//有返回值,无参数  
public int testB(){  
int i=100;  
if(i>100){  
return 1010;  
}else{  
return 1000;  
}  
}  
//无返回值,有参数  
public void testC(int n,int m){  
int num=n m;  
System.out.println(num);  
}  
//有返回值,有参数  
public int testD(int a,int b){  
int sum=a b;  
return sum;  
}  
  
}

八.方法重载

方法的重载  
 1.方法名相同, 参数类型不同  
 2.方法名相同, 参数个数不同  
3.方法名相同, 参数类型不同 顺序不同 也构成重载  
重载的作用: 功能不变 , 根据不同的参数 来实现相同的功能  
  
方法名相同 参数都一样 返回值不同 这不是重载 跟返回值没有半毛钱关系 跟参数列表有关

package com.bjsxt.pojo;  
  
public class Login {  
//账号密码登录  
public void login(String number,String password){  
  
}  
//手机验证码  
public void login(String phoneNumber,int passCode){  
  
}  
//微信  
public void login(String wechat){  
System.out.println("wechat");  
  
}  
//qq  
public void userLogin(int passwordqq,String usernameqq){  
  
}  
}

package com.bjsxt.test;  
  
import com.bjsxt.pojo.Login;  
  
public class LoginTest {  
public static void main(String[] args) {  
Login l= new Login();  
l.login("微信登录");  
  
}  
}

九.构造方法

构造方法: 就是一个特殊的方法而已  
 作用 : 就是用来实例化对象的  
 注意:  
 1. 构造方法的名字 必须和 类名一致  
 2. 构造方法 不写返回值类型 连void都不写  
 3. 构造方法是通过new 关键字进行调用的  
  
 构造方法的语法 非常固定  
1. 无参构造 (默认自带的构造)  
 public 类名(){  
 // 可以写java代码 也可以不写  
}  
 2. 带参构造  
 public 类名(参数列表){ // 1 ~ N个  
 // 可以写java代码 也可以不写  
 }  
 带参构造器的主要用途之一: 就是通过带参构造器给全局变量赋值

package com.bjsxt.test;  
  
import com.bjsxt.pojo.Users;  
  
public class UserTest {  
public static void main(String[] args) {  
Users user=new Users("张三",18);//带参构造,直接在这里面就把值赋给成员变量了  
  
//无参构造不用打.去调用方法  
user.users();  
  
}  
}

package com.bjsxt.pojo;  
  
public class Users {  
private String username;  
private int userage;  
//无参构造  
public Users(){  
System.out.println("嘿嘿");  
}  
public Users(String name,int age){  
System.out.println("name:" name);  
System.out.println("age:" age);  
username=name;//局部变量赋值给全局变量  
userage=age;//局部变量赋值给全局变量  
  
}  
public void users(){  
System.out.println("sssr");  
System.out.println("username:" username);  
System.out.println("userage" userage);  
}  
//  
  
  
}

如果只写一个带参构造器, 那么 无参构造器 默认就不提供了 想使用无参构造器的话 就必须显示的写出来才行

十.this关键字

this关键字的本质:**创建好的对象的地址**,由于在构造方法调用前，对象已经创
建。因此，在构造方法中也可以使用this来代表“**当前对象**” 的。

this关键字的作用之一  
此时 局部变量 和 全局变量同名了  
在java中 有个原则 叫: 就近原则 当局部变量和 全局变量同名的时候 优先使用局部变量  
此时 下面这种写法 不会将局部变量 接收到的数据 赋值给 全局变量 而是 赋值给了局部变量
当全局变量和局部变量同名的时候 因为就近原则的存在 所以赋值的时候 只会赋值给局部变量  
此时我们可以使用this关键 标记一下全局变量 直接写成 this.全局变量名 即可   当 局部变量和全局变量名 不同的时候 this关键字 可以省略不写

package com.bjsxt.pojo;  
  
public class Dog1 {  
String dogName;  
String dogAge;  
public Dog1(){}  
public Dog1(String dogName,String dogAge){  
this.dogName=dogName;  
this.dogAge=dogAge;  
}  
public void testB(){  
System.out.println(dogName);  
System.out.println(dogAge);  
}  
}


package com.bjsxt.test;  
  
import com.bjsxt.pojo.Dog;  
import com.bjsxt.pojo.Dog1;  
  
public class DogTest {  
public static void main(String[] args) {  
Dog dog=new Dog("luck",3);  
dog.test();  
Dog1 dog1=new Dog1("xiaohua","18");  
dog1.testB();  
  
}  
}

this关键字的作用之二 
通过this关键字 来调用其他的构造方法  
但是 我们使用this关键字 调用其他构造方法的时候 必须在第一行  
调用其他构造方法的时候 是根据参数个数 参数顺序 来自动调用匹配的构造方法

package com.bjsxt.pojo;  
  
public class Dog1 {  
String dogName;  
String dogAge;  
public Dog1(){  
System.out.println("heihei");  
}  
public Dog1(String dogName,String dogAge){  
this();  
this.dogName=dogName;  
this.dogAge=dogAge;  
}  
public void testB(){  
System.out.println(dogName);  
System.out.println(dogAge);  
}  
}


package com.bjsxt.pojo;  
  
public class Dog1 {  
String dogName;  
String dogAge;  
public Dog1(){  
System.out.println("heihei");  
}  
public Dog1(String dogName,String dogAge){  
this();  
this.dogName=dogName;  
this.dogAge=dogAge;  
}  
public void testB(){  
System.out.println(dogName);  
System.out.println(dogAge);  
}  
}

十一.形参和实参

所谓形参，就是在定义方法的时候，在参数表中定义的内容。这个时候，参数类型是主体内容，参数的名称并不重要。因为在定义后，只要传入同类型或匹配类型的数据就可以调用这个方法了。在Java中，形参的也称为： 形式参数。

所谓实参，就是在调用方法时，传入的具体的数据，这个时候，可以传入一个具体的值，或者保存着值的变量。在Java中，实参的也称为：实际参数。

十二.局部变量和全局变量

当在方法内部定义变量时，这个变量就是局部变量，其有效范围仅从定义变量的代码开始，到方法结束截至。方法定义时的参数也是局部变量。局部变量在其有效范围内，名称必须唯一。 （现在只要记住方法内定义的变量是局部变量即可）

这篇好文章是转载于：学新通技术网