Java面向对象-类与对象
类
// 一个JAVA源文件(xx.java)中可以定义多个类吗？
// 可以,但是只能有一个类是public的
类是对象的类型，不同于int等类型，类具有方法
对象是类的实例
类实例化得到对象
类命名规则：同变量名的命名规则，并且不可包含符号 . 或者空格。
类的定义
package CSDN;
//public访问控制符，表示这个类是公共的
//class关键字 表示定义一个类
//Student类名，首字母大写
public class Student {
//一个类中可以定义属性和方法
//属性的定义与之前的变量定义类似
int number; //学号 类的其中一个属性
String name; // 姓名 类的其中一个属性
// 方法
//introduction是方法的名字
public void introduction() { //方法
System.out.println("大家好,我是"+name+",学号是"+number);
}
} 对象的特征-- 属性、方法
- 属性--对象具有的各种特征；
- 方法--对象执行的操作；
- 对象同时具有属性和方法两项特性；
- 对象的属性和方法通常被封装在一起，共同体现事物的特性，二者相辅相承，不能分割
面向对象的特征
- 抽象：抽象就是忽略一个主题中与当前目标无关的方面，一遍更充分的注意与当前目标有关的方面。抽象包括两个方面，一是过程抽象，二是数据抽象；
- 继承：对象的一个新类可以从现有的类中派生，这个过程为类继承。新类继承了原始类的特性，新类成为原始类的子类，原始类成为新类的父类；
- 封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面；
- 多态性：多态性是指允许不同类的对象对同一消息作出响应。
方法的定义
格式：public 方法的返回值类型 方法名(){编写方法主体};
Java方法有返回值：如果方法有返回值，则方法主体中必须有return，语法：return 表达式；
Java方法没有返回值：如果方法没有返回值，则返回类型为void，方法主体中不一定需要return；
return放在方法主体最后或者if语句中。
返回值不是输出
方法的调用：·同类中，⽅法互相调⽤直接写⽅法名，不⽤⽣成对象(main⽅法除外)；
不同类中，先创建生成类对象，并初始化，通过”对象名.”调用。
package CSDN;
public class Dog { //第一个类Dog
String color = "黄色";
//void表示方法没有返回值
public void run() {
System.out.println("正在以0.1米每秒的速度向前奔跑");
}
//String表示方法会返回一个字符串
public String bark() {
String sound = "汪汪";
return sound;
}
}
package CSDN;
public class TestDog { //第二个类TestDog
public static void main(String[] args) {
Dog d = new Dog(); //创建生产第一个类的对象，对象名为d
System.out.println(d.color); 通过d.color调用第一个类中的color
//可以修改属性的值
//
d.color = "黑色";
//
System.out.println(d.color);
//输出 不等于 返回值
//没有返回值的方法,直接调用
d.run();
//有返回值的方法，可以接收返回值，进一步处理
String s = d.bark(); //将第一个类中bark的值赋给第二类中的s
System.out.println(s); //输出s的值
System.out.println(d.bark()); //通过d.bark()直接调用第一个类中的bark方法，因为第一个类中的bark方法有返回值，所以需要用System.out.println()进一步处理。
}
}创建类、属性、方法，调用方法
package CSDN;
public class score { //创建类，类名为score
String name;
int java;
int sql; //类的三个属性
public int sub(){ //创建方法sub()，有返回值为int
int sub;
if(sql>java){
sub=sql-java;
}else{
sub=java-sql;
}
return sub; //返回sub值，sub的数据类型为int
}
public void getSub(){ //创建方法getSub()
System.out.println("两门课的差的绝对值是："+sub()); //同类中调用sub()方法
}
public double avg(){ //创建方法avg()，有返回值double
double avg=(double)(java+sql)/2;
return avg;
}
public void getAvg(){ //创建方法getAvg()
System.out.println("两门课的平均分是："+avg()); //同类中调用avg()方法
}
}package CSDN;
import java.util.Scanner;
public class TestScore { //创建类TestScore
public static void main(String[] args) {
score sco=new score(); //创建score类对象名为sco，方便之后调用score中的方法
Scanner sc=new Scanner(System.in);
System.out.println("请输入学生姓名");
sco.name=sc.next();
System.out.println("请输入"+sco.name+"sql成绩");
sco.sql=sc.nextInt();
System.out.println("请输入"+sco.name+"java成绩");
sco.java=sc.nextInt();
sco.getSub(); //不同类中调用无返回值getSub()方法
sco.getAvg(); //不同类中调用无返回值getAvg()方法
}
}
//假如sco.getSub()是有返回值的方法，需要进一步对接收的值进行处理，一般处理的语句为System.out.printlin(sco.getSub());带参数的方法
之前的方法中例如getSub()，小括号()中是没有参数的，带参数的方法就是将参数填入小括号中，格式：数据类型 参数名1，数据类型 参数名2.....
package CSDN; //第一个类
public class calc {
public int add(int x,int y){ //参数为x，y，数据类型均为int
//属性用不到可以不定义
//()参数列表 格式：数据类型 参数1,数据类型 参数2.....
int sum=x+y;
return sum;
}
public int sub(int x,int y){ //参数为x，y，数据类型均为int
int sub;
if(x>y){
sub=x-y;
}else{
sub=y-x;
}
return sub;
}
public double avg(int x,int y){ //参数为x，y，数据类型均为int
double avg=(double)(x+y)/2;
return avg;
}
public int fac(int x){ //参数为x，，数据类型为int
int s=1;
for(x=x;x>0;x--){
s=s*x;
}
return s;
}
}
package CSDN; //第二个类中调用第一个类中参数
public class testcalc {
public static void main(String[] args) {
calc c=new calc();
System.out.println(c.add(6, 8));
System.out.println(c.avg(7, 8));
System.out.println(c.fac(4));
System.out.println(c.sub(9, 7)); //调用带参数的方法时需要填入方法参数
}
}构造方法
什么是构造方法
构造⽅法是⼀种特殊的方法
1. 创建并初始化对象的方法
2. 如果没有自定义构造方法，JAVA会提供⼀个默认的⽆参的构造⽅法
3. 如果有自定义有构造方法，默认的构造⽅法就不能在调⽤
为什么要自定义构造方法
简化对象的初始化过程
如何定义构造方法
1. 构造⽅法的⽅法名必须跟类名相同
2. 构造⽅法没有返回值类型，也不能有void 只要满⾜以上两点要求，就是构造⽅法
简单来说，构造方法负责对象成员的初始化工作，为实例变量赋予合适的初始值
package CSDN;
public class Employee {
private String name;
private int age;
private String education;
private String job;
//构造方法：生成对象并初始化的方法
//如果没有自定义构造方法，JAVA会提供一个默认的无参数构造方法
//如果自定义构造方法，默认的构造方法就不能调用了
//自定义构造方法
//1.方法名必须与类名一致
//2.构造没有返回值类型，连void也不能写
//只要同时满足以上两点要求的方法，就是构造方法
public Employee(String name,int age,String education,String job) {
this.name = name;
if(age>=18) {
this.age =age;
}else {
System.out.println("员工最小年龄要求18岁");
this.age = 18;
}
this.education =education;
this.job = job;
}
//构造方法重载
public Employee(String name,int age,String education) {
this.name = name;
if(age>=18) {
this.age =age;
}else {
System.out.println("员工最小年龄要求18岁");
this.age = 18;
}
this.education =education;
this.job = "待分配";
}
//普通方法的方法名也可以跟类名相同，但是不建议这么命名
public void Employee(){
System.out.println("I am a employee");
}
//自定义的无参的构造方法
public Employee() {
System.out.println("I am a constructor");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>=18) {
this.age = age;
}else {
System.out.println("员工最小年龄要求18岁");
this.age = 18;
}
}
}带参数的构造方法
显式的为实例变量赋予初始值
package CSDN; //第一个类
import java.util.Scanner;
public class Student {
String name;
int age;
public Student(String pname,int page){ //带参数的构造方法
name=pname;
if(page>=18){
age=page;
}else{
int a;
do{
System.out.println("年龄不能小于18岁，请重新输入：");
Scanner in=new Scanner(System.in);
a=in.nextInt();
}while(a<18);
age=a;
}
}
public void introduction(){
System.out.println("大家好！我的名字是"+name+"。我今年"+age+"岁啦");
}
public void introduction(String caiyi){
System.out.println("大家好！我的名字是"+name+"。我今年"+age+"岁啦");
System.out.println("表演的节目是："+caiyi);
}
}
package CSDN; //第二个类
public class TestStudent {
public static void main(String[] args) {
Student s1=new Student("张三", 18); //调用带参数的构造方法
s1.introduction();
s1.introduction("唱歌");
}
}方法重载
同样的方法名，但数据类型不同，典型例子print()包含int、double、String等数据类型的print()。
- 参数类型不同--可以
- 参数个数不同--可以
- 参数顺序不同--不⼀定，顺序不同⽽且要类型不同
变量的作用域
变量声明的位置决定变量作用域，变量作用域可在程序中按变量名访问该变量的区域。
在哪个{ }内声明的变量，该变量只作用于这个{ }内。
1172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
