Java类的定义：

成员变量会默认初始化，局部变量不会默认初始化。

如何在内存中区分类和对象：

♦类是静态的概念，代码区

♦对象是new出来的，位于堆内存，类的每一个成员变量在不同的对象中都有不同的值(除了静态变量)而方法只有一份，执行的时候才占用内存。

对象的创建和使用：

♦必须使用new关键字创建对象

♦使用对象(引用).成员变量或来引用对象的成员变量

Dog d = new Dog();

d.getFurColor();

♦使用对象(引用).方法(参数列表)来调用对象的方法

Dog d = new Dog();

Mouse mm = new Mouse();

d.catchMouse(mm);

♦同一类的每个对象有不同的成员变量存储空间

♦同一类的每个对象共享该类的方法

Dog类：

public classDog {

String furColor;floatheight;floatweight;voidcatchMouse(Mouse m) {

m.scream(m);

}public static voidmain(String[] args) {

Dog d= newDog();

Mouse mm= newMouse();

d.getFurColor();

d.catchMouse(mm);

}

}

Persion类：

public classPersion {public static voidmain(String[] args) {

Persion p= newPersion();

Persion p1= new Persion(400);

p.info();

p.info("ok");

}//成员变量

private intid;private int age = 20;//方法定义

public int getAge(){returnage;}public void setAge(int i){age =i;}public int getId(){returnid;}voidinfo() {

System.out.println("my id is :" +id);

}voidinfo(String t){

System.out.println(t + "id" +id);

}

Persion(){

id= 100;

age= 20;

}

Persion(int_id){

id=_id;

age= 30;

}

Persion(int _id,int_age){

id=_id;

age=_age;

}

}

构造方法重载：

♦与普通方法一样，构造方法也可以重载

Persion(){

id= 100;

age= 20;

}

Persion(int_id){

id=_id;

age= 30;

}

Persion(int _id,int_age){

id=_id;

age=_age;

}

this关键字：

♦在类的方法定义中使用的this关键字代表使用该方法的对象的引用

♦当必须指出当前使用方法的对象是谁时要使用this

♦使用this可以处理方法中成员变量和参数重名的情况

♦this可以看作一个变量，它的值是当前对象的引用

super关键字：

♦在类中，用static声明的成员变量为静态变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份

♦用static声明的方法为静态方法，在调用改方法时，不会讲对象的引用传递给他，所以在static方法中不可访问非static的成员

静态方法不再是针对于某个对象调用，所以不能访问非静态成员

♦可以通过对象的引用或类名(不需要实例化)访问静态变量。

public classCat {private static int sid = 0;privateString name;intid;

Cat(String name){this.name =name;

id= sid++;

}public voidinfo(){

System.out.println("My name is"+name+"No."+id);

}public static voidmain(String[] args) {

Cat.sid= 100;

Cat mimi= new Cat("mimi");

Cat pipi= new Cat("pipi");

mimi.info();

pipi.info();

}

}

继承：

public classPersion {privateString name;private intage;publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

}class Student extendsPersion{privateString school;publicString getSchool() {returnschool;

}public voidsetSchool(String school) {this.school =school;

}

}classTest{public static voidmain(String[] args) {

Student student= newStudent();

student.setName("John");

student.setSchool("SCH");

student.setAge(24);

System.out.println(student.getName());

System.out.println(student.getAge());

System.out.println(student.getSchool());

}

}

方法重写：

♦在子类中可以根据需要对从基类中继承来的方法进行重写

♦重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型

♦重写方法不能使用比被重写方法更严格的访问权限

classPerson {privateString name;private intage;public void setName(String name){this.name=name;}public void setAge(int age) {this.age=age;}public String getName(){returnname;}public int getAge(){returnage;}publicString getInfo() {return "Name: "+ name + "\n" +"age: "+age;

}

}class Student extendsPerson {privateString school;public String getSchool() {returnschool;}public voidsetSchool(String school)

{this.school =school;}publicString getInfo() {return "Name: "+ getName() + "\nage: "+getAge()+ "\nschool: "+school; //重写

}

}public classTestOverWrite {public static voidmain(String arg[]){

Student student= newStudent();

Person person= newPerson();

person.setName("none");

person.setAge(1000);

student.setName("John");

student.setAge(18);

student.setSchool("SCH");

System.out.println(person.getInfo());

System.out.println(student.getInfo());

}

}

super关键字：

♦在java类中使用super来引用基类的成分：

public classTestInherit {public static voidmain(String[] args) {

ChildClass cc= newChildClass();

cc.f();

}

}class ChildClass extendsFatherClass{public intvalue;public voidf(){super.f();

value= 200;

System.out.println("ChildClass.value="+value);

System.out.println(value);

System.out.println(super.value);

}

}classFatherClass{public intvalue;public voidf(){

value= 100;

System.out.println("FatherClass.value="+value);

}

}

打印结果为：

FatherClass.value=100ChildClass.value=200

200

100

继承中的构造方法：

♦子类的构造的过程中必须调用其父类的构造方法

注释super(300)；会报错。原因如上

SubClass() {

super(300);

System.out.println("SubClass()");

}

♦子类可以在自己的构造方法中使用super(argument_list)调用父类的构造方法。

◊使用this(argument_list)调用本类的另外的构造方法。

◊如果使用super，必须写在子类构造方法的第一行。

调换super(300)位置；会报错。原因如上

SubClass() {

super(300);

System.out.println("SubClass()");

}

♦如果子类的构造方法中没有显示地调用父类构造方法，则系统默认调用父类的无参构造方法。

public classTestSuperSub {public static voidmain(String[] args) {//SubClass sc1 = new SubClass();

SubClass sc2 = newSubClass();

}

}

打印结果：

SuperClass(300)

SubClass()

♦如果子类构造方法中既没有显示调用父类构造方法，而父类中有没有无参构造方法，则编译出错。

注释这个父类的构造方法，编译出错，原因如上。

SuperClass() {

System.out.println("SuperClass()");

}

整体练习代码：

packagecom.luluyu.test;public classTestSuperSub {public static voidmain(String[] args) {

SubClass sc1= newSubClass();

SubClass sc2= newSubClass();

}

}classSuperClass {private intn;

SuperClass() {

System.out.println("SuperClass()");

}

SuperClass(intn) {

System.out.println("SuperClass(" + n + ")");this.n =n;

}

}class SubClass extendsSuperClass {private intn;

SubClass(intn) {//super();

System.out.println("SubClass(" + n + ")");this.n =n;

}

SubClass() {super(300);

System.out.println("SubClass()");

}

}

对象转型：

♦一个父类的引用类型变量可以“指向”其子类的对象。

♦一个父类的引用不可以访问其子类对象新增加的成员(属性和成员)。

♦可以使用引用变量instanceof类名来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

♦子类的对象可以当作父类的对象来使用称作向上转型，反之称为向下转型。

练习代码：

package com.luluyu.test;

public class test {

public static void main(String[] args) {

Animal a = new Animal("name");

Cat c = new Cat("catname","blue");

Dog d = new Dog("dogname","black");

System.out.println(a instanceof Animal);//true

System.out.println(c instanceof Animal);//true

System.out.println(d instanceof Animal);//true

System.out.println(a instanceof Cat);//false

a = new Dog("bigyellow","yellow");

System.out.println(a.name);//bigyellow

System.out.println(a instanceof Animal);//true

System.out.println(a instanceof Dog);//true

Dog d1 = (Dog) a;//强制类型转化

System.out.println(d1.eyesColor);//yellow

}

}

class Animal{

public String name;

public Animal(String name) {

this.name = name;

}

}

class Cat extends Animal{

public String eyesColor;

Cat(String n,String c) {

super(n);

eyesColor=c;

}

}

class Dog extends Animal{

public String eyesColor;

Dog(String n,String c) {

super(n);

eyesColor=c;

}

多态绑定和多态：

动态绑定是指在执行期间(而非编译期间)判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态需要三个条件：

1.要有继承

2.要有重写

3.父类引用指向子类对象

packagecom.luluyu.op;public classTest {public static voidmain(String[] args) {

Cat c= new Cat("catname", "blue");

Dog d= new Dog("Dogname", "black");

Lady L1= new Lady("L1", c);

Lady L2= new Lady("L2", d);

L1.myPetEnjoy();

L2.myPetEnjoy();

}

}classAnimal {privateString name;publicAnimal(String name) {super();this.name =name;

}public voidenjoy() {

System.out.println("叫声。。。。。。。。");

}

}class Cat extendsAnimal {privateString eyesColor;publicCat(String n, String c) {super(n);

eyesColor=c;

}public voidenjoy() {

System.out.println("猫叫声。。。。。。。");

}

}class Dog extendsAnimal {privateString furColor;publicDog(String n, String c) {super(n);

furColor=c;

}public voidenjoy() {

System.out.println("狗叫声。。。。。。。");

}

}classLady {privateString name;privateAnimal pet;publicLady(String name, Animal pet) {this.name =name;this.pet =pet;

}public voidmyPetEnjoy() {

pet.enjoy();

}

}

抽象类：

♦用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

♦含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写

♦抽象类不能被实例化

♦抽象方法只需声明，而不被实现

/***

* 当一个类有抽象方法时，这个类必须是抽象类

**/

abstract classAnimal {privateString name;publicAnimal(String name) {super();this.name =name;

}public abstract voidenjoy();

}

abstract classAnimal {privateString name;publicAnimal(String name) {super();this.name =name;

}public abstract voidenjoy();

}/***

*含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写*/

abstract class Cat extendsAnimal {privateString eyesColor;publicCat(String n, String c) {super(n);

eyesColor=c;

}public abstract voidenjoy();

}

final关键字：

♦final修饰变量的值不能够被改变

◊final修饰的成员变量

◊final修饰的局部变量(形参)

♦final修饰的方法不能够被重写

♦final修饰的类不能够被继承

接口：

♦接口是抽象方法和常量值的定义的集合

♦从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现

public interfaceRunner {public voidstart();public voidrun();public voidstop();

}

接口的特性：

♦接口可以多重实现

♦接口中声明的属性默认为public static final的，也只能是public static final

♦接口中只能定义抽象方法，而且这些方法默认为public，也只能是public

♦接口可以继承其它的的接口，并添加新的属性和抽象方法