java 面向对象继承的思想_Java面向对象思想
Java類的定義：
成員變量會默認初始化，局部變量不會默認初始化。
如何在內存中區(qū)分類和對象：
?類是靜態(tài)的概念，代碼區(qū)
?對象是new出來的，位于堆內存，類的每一個成員變量在不同的對象中都有不同的值(除了靜態(tài)變量)而方法只有一份，執(zhí)行的時候才占用內存。
對象的創(chuàng)建和使用：
?必須使用new關鍵字創(chuàng)建對象
?使用對象(引用).成員變量或來引用對象的成員變量
Dog d = new Dog();
d.getFurColor();
?使用對象(引用).方法(參數(shù)列表)來調用對象的方法
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可以處理方法中成員變量和參數(shù)重名的情況
?this可以看作一個變量，它的值是當前對象的引用
super關鍵字：
?在類中，用static聲明的成員變量為靜態(tài)變量，它為該類的公用變量，在第一次使用時被初始化，對于該類的所有對象來說，static成員變量只有一份
?用static聲明的方法為靜態(tài)方法，在調用改方法時，不會講對象的引用傳遞給他，所以在static方法中不可訪問非static的成員
靜態(tài)方法不再是針對于某個對象調用，所以不能訪問非靜態(tài)成員
?可以通過對象的引用或類名(不需要實例化)訪問靜態(tài)變量。
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());
}
}
方法重寫：
?在子類中可以根據(jù)需要對從基類中繼承來的方法進行重寫
?重寫方法必須和被重寫方法具有相同方法名稱、參數(shù)列表和返回類型
?重寫方法不能使用比被重寫方法更嚴格的訪問權限
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()");
}
?如果子類的構造方法中沒有顯示地調用父類構造方法，則系統(tǒng)默認調用父類的無參構造方法。
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;
}
多態(tài)綁定和多態(tài)：
動態(tài)綁定是指在執(zhí)行期間(而非編譯期間)判斷所引用對象的實際類型，根據(jù)其實際的類型調用其相應的方法。
多態(tài)需要三個條件：
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來修飾一個方法時，該方法叫做抽象方法。
?含有抽象方法的類必須被聲明為抽象類，抽象類必須被繼承，抽象方法必須被重寫
?抽象類不能被實例化
?抽象方法只需聲明，而不被實現(xiàn)
/***
* 當一個類有抽象方法時，這個類必須是抽象類
**/
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修飾的類不能夠被繼承
接口：
?接口是抽象方法和常量值的定義的集合
?從本質上講，接口是一種特殊的抽象類，這種抽象類只包含常量和方法的定義，而沒有變量和方法的實現(xiàn)
public interfaceRunner {public voidstart();public voidrun();public voidstop();
}
接口的特性：
?接口可以多重實現(xiàn)
?接口中聲明的屬性默認為public static final的，也只能是public static final
?接口中只能定義抽象方法，而且這些方法默認為public，也只能是public
?接口可以繼承其它的的接口，并添加新的屬性和抽象方法
總結
以上是生活随笔為你收集整理的java 面向对象继承的思想_Java面向对象思想的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： C++ 杂谈之去除空格
- 下一篇： java导出excel 科学计数法_基于