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
♦接口可以继承其它的的接口，并添加新的属性和抽象方法
