首页 > 代码库 > 面向对象编程
面向对象编程
创建对象并使用
Student student = new Student()
使用对象的属性
student.name = "leader";
System.out.println(student.age);
使用对象的方法
student.study();
方法的定义
修饰符 返回值类型 方法名（参数列表）｛
方法体
return 返回值；
｝
返回值类型要和返回值匹配。
public void study(){
System.out.println(name+"正在学习");
}
方法签名就是：方法名+参数列表
方法类型
有返回值:
1.有参数列表
2.没有参数列表
没有返回值
1.有参数列表
2.没有参数列表
形参和实参
//此处a和b是形参
public int add(int a,int b){
int temp =0;
if(temp < a){
temp = a;
}
if(temp < b){
temp = b;
}
return temp;
}
//此处的34和89是实参
student.add(34,89);
int x =70;
int y =50;
//x和y是实参
student.add(x,y);
局部变量：定义在方法体或者是方法的声明上的变量
作用范围：整个方法。
使用：声明后必须赋值才能使用
a和b就是局部变量
成员变量：属性就是成员变量
作用范围：整个类。
使用：可以直接使用，因为系统会给成员变量赋默认值
name,banji,id,age 就是成员变量
String类的使用：
String对象是不可变的。
String的各种方法：API文档
面向对象的三大特征：
封装、 继承、 多态
封装：
1.创建类就是一种封装
2.对属性私有化，同时提供公开的set、get方法
public class HH{
private String aa;
private int bb;
public String getAa() {
return aa;
}
public void setAa(String aa) {
this.aa = aa;
}
public int getBb() {
return bb;
}
public void setBb(int bb) {
this.bb = bb;
}
}
除非必须公开底层实现细节，否则应该将所有字段指定为private加以封装
使用字段封装，通过增加数据访问限制，增强了类的可维护性
四种访问修饰符：
public protected default（默认） private
public：在什么地方都可以访问。
private：只能在本类中可以访问
构造方法
1.方法名和类名一样
2.没有返回值类型
public Student(){
}
public Student(String name,int age){
this.name = name;
this.age =age;
}
构造方法的作用：创建对象时给属性赋值
this关键字：当前对象的引用。
用来处理成员变量和方法中的局部变量同名时的问题
public setName(String a){
name = a;
}
public void setName(String name){
this.name = name;
}
this();当前对象的无参构造方法，只能用在构造方法中，并且必须放在第一句。
this(参数);调用有参构造方法。
public Student(String name,int age){
this();//调用了无参构造方法。
this.name = name;
this.age = age;
}
static关键字：
凡是被static修饰就称为静态属性或静态方法
1.随着类的加载而加载，优先于对象的存在。
2.只执行一次。（因为类只加载一次） 共享
3.静态的只能访问静态的
static int a = 10;
int b =20;
public static void study(){
System.out.println("静态方法");
System.out.println(a);
//System.out.println(b);错误，因为b在内存中还不存在
}
4.静态方法中不能使用this关键字
使用：类名.静态属性 或者 类名.静态方法
Student.study();
单例模式：
1.static
2.构造方法私有化。
重载（overload）：在一个类中，方法名相同而参数列表不同的方法可以同时存在
public void run(){
System.out.println("我能跑2000米");
}
public void run(int b){
System.out.println("我能跑"+b+"米");
}
方法的重载就是方法签名不同。
继承
//People 就是父类
class People{
String name = "leader";
int age;
public People() {
System.out.println("父类的无参构造方法");
}
public void show(){
System.out.println(name+"-------"+age);
}
}
//Teacher 就是子类
class Teacher extends People{
String name ="mahatma";
public Teacher() {
super();//不写的话会默认调用父类的无参构造方法
System.out.println("子类的无参构造方法");
}
public Teacher(String name){
this.name =name;
System.out.println("子类的有参构造方法");
}
public void t(){
//super：区分子父类出现的同名成员。
System.out.println(name);
System.out.println(super.name);
}
public void show(){
System.out.println("代码重写，实现多态");
}
}
作用：代码重用。
super关键字：父类对象的引用
Teacher t = new Teacher();
t.t();
子类中所有的构造方法都会默认的调用super()；来对父类对象初始化。
super();//只能放在第一行，并且只能在子类的构造方法中使用
重写：子类对从父类继承过来的方法进行改写，是多态机制的前奏
注意：
1.继承
2.方法名称、参数列表、返回值类型都不能改变
3.权限只能越来越大。但是一般情况下保持一致
4.父类的私有方法不能被重写
5.在子类的重写方法中如果需要调用父类的被重写方法，可以通过super.方法
final关键字：修饰类，变量，方法
修饰后的改变：
类：不能被继承
变量：一旦赋值，不能在改变
方法：不能被重写
所有的类都直接或者间接继承Object类
toString();//打印对象时默认调用
equals();//比较对象的内容。
多态：
1.继承
2.重写
3.父类对象对子类对象的引用（父类引用指向子类对象）
People people = new Teacher();
作用：用来做参数的传递。
面向对象编程