码迷，mamicode.com
首页 > 编程语言 > 详细

Java面向对象思想

时间：2018-05-11 20:32:53      阅读：180      评论：0      收藏：0      [点我收藏+]

标签：抽象类   父类   抽象   参数   anim   列表   堆内存   his   on()   

Java类的定义：

技术分享图片 

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

技术分享图片

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

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

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

对象的创建和使用：

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

  ?使用对象（引用).成员变量或来引用对象的成员变量    

　　Dog d = new Dog();
　　d.getFurColor();

  ?使用对象（引用).方法（参数列表）来调用对象的方法   

　　Dog d = new Dog();
　　Mouse mm = new Mouse();
　　d.catchMouse(mm);

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

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

Dog类：

public class Dog {
    
    String furColor;
    float height;
    float weight;

    void catchMouse(Mouse m) {
        m.scream(m);
    }
    public static void main(String[] args) {
        Dog d = new Dog();
        Mouse mm = new Mouse();
        d.getFurColor();
        d.catchMouse(mm);

    }    
}

技术分享图片

 技术分享图片

Persion类：

public class Persion {
    
    public static void main(String[] args) {
        Persion p = new Persion();
        Persion p1 = new Persion(400);
        p.info();
        p.info("ok");
    }

    //成员变量
    private int id;
    private int age = 20;
    //方法定义
    public int getAge(){return age;}
    public void setAge(int i){age = i;}
    public int getId(){return id;}
    
    void info() {
        System.out.println("my id is :" + id);
    }
    
    void info(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 class Cat {
    
    private static int sid = 0;
    private String name;
    int id;
    
    Cat(String name){
        this.name = name;
        id = sid++;
    }
    public void info(){
        System.out.println("My name is"+name+"No."+id);
    }

    public static void main(String[] args) {
        Cat.sid = 100;
        Cat mimi = new Cat("mimi");
        Cat pipi = new Cat("pipi");
        mimi.info();
        pipi.info();
    }
}

 技术分享图片

继承：

public class Persion {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

}

class Student extends Persion{
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }    
}

class Test{
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("John");
        student.setSchool("SCH");
        student.setAge(24);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSchool());
    }
}

 

方法重写：

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

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

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

class Person {
    private String name;
    private int age;
    public void setName(String name){this.name=name;}
    public void setAge(int age) {this.age=age;}
    public String getName(){return name;}
    public int getAge(){return age;}
    public String getInfo() {
          return "Name: "+ name + "\n" +"age: "+ age;
  }
}

class Student extends Person {
    private String school;
    public String getSchool() {return school;}
    public void setSchool(String school)
    {this.school =school;}
    public String getInfo() {
      return  "Name: "+ getName() + "\nage: "+ getAge() 
                    + "\nschool: "+ school;    //重写
        }
}

public class TestOverWrite {
public static void main(String arg[]){
        Student student = new Student();
        Person person = new Person();
        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 class TestInherit {
    
    public static void main(String[] args) {
        ChildClass cc = new ChildClass();
        cc.f();
    }
    
}

class ChildClass extends FatherClass{
    public int value;
    public void f(){
        super.f();
        value = 200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value);
    }
}

class FatherClass{
    public int value;
    public void f(){
        value = 100;
        System.out.println("FatherClass.value="+value);
    }
}

打印结果为：
FatherClass.value=100
ChildClass.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 class TestSuperSub {

    public static void main(String[] args) {
        //SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass();
    }

}
打印结果：
SuperClass(300)
SubClass() 

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

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

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

整体练习代码：

package com.luluyu.test;

public class TestSuperSub {

    public static void main(String[] args) {
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass();
    }

}

class SuperClass {
    private int n;

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

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

class SubClass extends SuperClass {
    private int n;

    SubClass(int n) {
        // 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.父类引用指向子类对象

 

package com.luluyu.op;

public class Test {

    public static void main(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();

    }

}

class Animal {
    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }

    public void enjoy() {
        System.out.println("叫声。。。。。。。。");
    }
}

class Cat extends Animal {

    private String eyesColor;

    public Cat(String n, String c) {
        super(n);
        eyesColor = c;
    }

    public void enjoy() {
        System.out.println("猫叫声。。。。。。。");
    }

}

class Dog extends Animal {

    private String furColor;

    public Dog(String n, String c) {
        super(n);
        furColor = c;
    }

    public void enjoy() {
        System.out.println("狗叫声。。。。。。。");
    }

}

class Lady {

    private String name;
    private Animal pet;

    public Lady(String name, Animal pet) {
        this.name = name;
        this.pet = pet;
    }

    public void myPetEnjoy() {
        pet.enjoy();
    }

}

 

 

 

 

抽象类：

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

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

   ?抽象类不能被实例化

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

/**
 * 
 * 当一个类有抽象方法时，这个类必须是抽象类
 *
 */
abstract class Animal {
    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }

    public abstract void enjoy();
}

 

 

 

 

abstract class Animal {
    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }
    public abstract void enjoy();
}


/***
 *含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
 */
abstract class Cat extends Animal {

    private String eyesColor;

    public Cat(String n, String c) {
        super(n);
        eyesColor = c;
    }

    public abstract void enjoy();

}

 

 

 

final关键字：

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

        ?final修饰的成员变量

        ?final修饰的局部变量（形参）

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

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

接口：

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

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

 

public interface Runner {

    public void start();
    public void run();
    public void stop();
}

 

 

 

接口的特性：

   ?接口可以多重实现

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

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

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

 

 

   

 

Java面向对象思想

标签：抽象类   父类   抽象   参数   anim   列表   堆内存   his   on()   

原文地址：https://www.cnblogs.com/joy410-love/p/8469359.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！