面向对象基础

1.什么是类:

类是一个概念(名词)抽象的定义。 类定义了该类型对象的数据结构,称之为“成员变量”,同时,也定义了一些可以被调用的功能,称之为“方法”。 类是用于构建对象的模板,对象的实质就是内存中一块存储区域,其数据结构由定义它的类来决定。

2.面向对象的三大特征:继承、封装、多态

3.什么是方法的重载:

在 Java 语言中,允许多个方法的名称相同,但参数列表不同,称之为方法的重载(overload)。 编译器在编译时会根据其参数的不同,绑定到不同的方法。

4.什么是构造方法:

在 Java 语言中可以通过构造方法实现对对象成员变量的初始化。构造方法是在类中定义的方法。但不同于其他的方法,构造方法的定义有如下两点规则: 1.构造方法的名称必须与类名同名。 2.构造方法没有返回值,但也不能写 void。

5.String a=”codingke”和 String a= new String(“codingke”)的区别:前者有可能不需要创建对象,如果常量池存在的话,后者可能最少创建一个对象,吐过常量池不存在,还需要把对象保存到常量池中。前者效率更高一些。 

package com.codingke;


/**
 * 
 * 
 * @author 扣丁学堂(www.codingke.com)
 */
public class Rabbit {
boolean sex;
double weight;
String color;
String name;


// 构造方法
Rabbit() {
this(false, 2.0, "白兔", "玉兔");
}


// 构造方法
Rabbit(boolean sex, double weigth, String color, String name) {


this.sex = sex;
this.weight = weigth;
this.color = color;
this.name = name;


}


// 封装一个printInfo()
public void printInfo() {
System.out.println(sex + "\t" + weight + "\t" + color + "\t" + name);
}


public void eat() {


}


public void jump() {


}
}

package com.codingke;


/**
 * 
 * 
 * @author 扣丁学堂(www.codingke.com)
 */
public class Student {
String name;
int age;
char sex;
double eScore;
double mScore;
double cScore;


// 空的构造方法
Student() {


}


// 带参数的构造方法
Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}


Student(String name, int age, char sex, double eScore, double mScore,
double cScore) {
this(name, age, sex);
this.eScore = eScore;
this.mScore = mScore;
this.cScore = cScore;
}


/**
* 求学生的分数总和：谁调用就是求谁的,因为谁调用谁就是this
* 
* @return
*/
public double getSum() {
// this
return this.eScore + this.cScore + this.mScore;


}


/**
* 求学生的平均分：谁调用谁就是this，先调用该对象的getSum方法求总和，然后再求评分均
* 
* @return
*/
public double getAvg() {
return this.getSum() / 3;
}


public void printInfo() {
System.out.println(name + "\t" + age + "\t" + sex + "\t" + eScore
+ "\t" + mScore + "\t" + cScore);
System.out.println("\t" + getSum() + "\t" + getAvg());
}


}

package com.codingke;


/**
 * 封装一个兔子类,具有属性性别、体重、毛色、姓名。行为：吃、跳。
 * 
 * @author 扣丁学堂(www.codingke.com)
 */
public class Homework1 {
/**
* @param args
*/
public static void main(String[] args) {
Rabbit r1 = new Rabbit();


// 调用r1的printinfo（）方法
r1.printInfo();
}
}

package com.codingke;


/**
 * 封装一个学生类，有姓名，有年龄，有性别，有英语成绩，数学成绩，语文成绩，封装方法，求总分，平均分，以及打印学生的信息。
 * 
 * @author 扣丁学堂(www.codingke.com)
 */
public class Homework2 {
public static void main(String[] args) {
// 创建一个stu1的学生
Student stu1 = new Student();
// 设置set学生的相关分数
stu1.name = "威哥";
stu1.age = 18;
stu1.sex = '男';
stu1.eScore = 99.9;
stu1.mScore = 98.9;
stu1.cScore = 99.7;
// 打印学生的信息
stu1.printInfo();
Student stu2 = new Student("小丁", 17, '女');
stu2.eScore = 55.6;
stu2.mScore = 33.8;
stu2.cScore = 59.9;
stu2.printInfo();
Student stu3 = new Student("小米", 20, '女', 87.8, 67.9, 100.0);
stu3.printInfo();
System.out.println(stu1.getAvg());
System.out.println(stu2.getAvg());
System.out.println(stu3.getAvg());
System.out.println(stu1.getSum());
System.out.println(stu2.getSum());
System.out.println(stu3.getSum());
}
}

1.this关键字：

（1）代表本类的对象，就可以访问本类的方法和属性。

 局部变量和成员变量重名，用this.成员变量来区分。

（2）this()代表本类的构造函数。

     this(形参列表)；位于首行。

1. 构造函数：

 创建并初始化对象。

 声明：没有返回值

 [public]方法名(形参列表)

 构造函数的方法名字要求与类一致。

1. static关键字：

 静态的意思。修饰符。

 修饰属性，方法，代码块，类(内部类)

 static修饰属性：类成员变量,属于类。只有一份，所有的对象共享一份。但最好用类去访问。对象也可以访问。

 非static的属性属于对象所有。只有对象能够访问。创建对象才能够访问。

 作用：

 修饰方法：类方法。由类调用，对象其实也可以调用。

 静态方法中，不能访问非静态的属性。静态方法由类调用，此时可能没有对象，就没有非静态的属性。反过来，在非静态方法中，可以调用静态属性。

 在静态方法中，不能出现this和super关键字。

1. 单例模式：

 （1）饿汉式：

  public class EagerSingleton  {  

   private static final EagerSingleton m_instance =  new EagerSingleton();  

  /**  * 私有的默认构造子  */  

   private EagerSingleton() { }  

  /**  * 静态工厂方法  */ 

   public static EagerSingleton getInstance()  { 

return m_instance; 

  } 

}

 （2）懒汉式：

 public class LazySingleton  {  

  private static LazySingleton  m_instance = null;  

  /**  * 私有的默认构造子，保证外界无法直接实例化  */ 

  private LazySingleton() { } 

  /**  * 静态工厂方法，返还此类的惟一实例  */ 

 synchronized public static LazySingleton  getInstance()  {  

   if (m_instance == null)  { 

    m_instance = new LazySingleton();  

     }  

  return m_instance;  

} 

}