您现在的位置是:网站首页>javajava

java面向对象的三大特征基础

deling2019年4月4日java277人已围观

简介java的三大特征:封装、继承、多态!

封装

类的属性私有化,对外提供公共的get和set方法 

封装的优点:

  1. 良好的封装能够减少耦合。

  2. 类内部的结构可以自由修改。

  3. 可以对成员变量进行更精确的控制。

  4. 隐藏信息,实现细节。

例如: 类:

public class Dog {	
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) {		
	if(age<=0) {
			System.out.println("你输入的年龄太小!");
		}		
	else 
		this.age = age;
	}

}

实例化对象类:

public class TestDog {
public static void main(String[] args) {	
// TODO Auto-generated method stub
	Dog d = new Dog();
	d.setName("小花猫");
	d.setAge(1);
	System.out.println(d.getName());
	System.out.println(d.getAge());
}

}

继承

使用已存在的类的定义作为基础建立新类,新类的定义可以增加新的数据和新的功能,也可以用父类的功能,但不能选择性地继承父类

  • 基础类叫做父类或者基类

  • 新创建的类叫做子类或者派生类

继承的初始化顺序:父类的静态成员方法 子类的静态方法 父类的构造方法 子类的构造方法

注意:

  • Object是所有类的祖先类!除了Object,其余类都有一个父类!但是一个子类只能有一个父类!

  • 继承不支持多继承,但支持多重继承!

  • 子类只能获取到父类的非私有成员,不能获取到父类的私有成员

  • 子类调用父类的构造方法默认是无参构造,调用带参构造要用super关键字

  • 当父类没有无参构造时,子类调用父类的构造方法会报编译错误!

  • 父类不可以访问子类特有的成员!

继承常用关键字:extends

this:

  • 访问本类的构造方法

  • 访问本类的成员属性

  • 访问本类的成员方法

  • 不能在静态方法中使用this关键字

this(参数)  
 //注意:构造方法必须要有this,而返回类型的方法可要可不要!

 调用返回类型的方法 
 
 this.方法名(参数) 
//  this可要可不要。

super:

  • 在有继承关系的子类中

  • 访问对象的父类中的成员方法

  • 访问对象的父类中的构造方法,

  • 访问对象的父类中的成员属性,

  • 不能在静态方法中使用super关键字

格式:

子类调用父类的成员方法和属性   
 super.方法名(参数);               //默认的无参构造方法没有参数
    super.属性="值";  
    
    调用父类的构造方法格式:      
    super(参数);
父类的构造方法不能被子类的成员方法中继承和被重写,但是子类的构造方法能访问父类的构造方法!

例如:

Animal(父类):

package com.animal; // com.animal 包/*
 * 私有化属性
 */public class Animal {	
 private String name;   // 名字
	private  int month;      // 月份
	private String species;  // 品种
	/*
	 * 添加无参构造方法
	 */
	public Animal() {
	
	}	
	public int getMonth() {		
	    return month;
	}	
	public void setMonth(int month) {		
	    this.month = month;
	}	
	public String getSpecies() {		
	    return species;
	}	
	public void setSpecies(String species) {		
	    this.species = species;
	}	
	public String getName() {		
	    return name;
	}	
	public void setName(String name) {		
	    this.name =name;
	}	
	// 吃 方法
	public void eat() {
		System.out.println(this.getName()+"在吃东西");
	}
}

Cat(子类):

package com.animal; // com.animal 包/*
 * 私有化属性
 */public class Cat extends Animal{	
 private double weight;	// 体重
	/*
	 * 无参构造方法
	 */
	public Cat() {
		
	}	
	public double getWeight() {		
	    return weight;
	}	
	public void setWeight(double weight) {		
	    this.weight = weight;
	}	
	/*
	 * 跑方法
	 */
	public void run() {
		System.out.println(this.getName()+"是一只"+this.getSpecies()+",它在快乐地奔跑!");
	}
 
}

Dog(子类):

package com.animal; //com.animal 包/*
 * 私有化属性
 */public class Dog extends Animal {	
 private String sex;       // 性别
	/*
	 * 无参构造方法
	 */
	public String setSex() {		
	    return sex;
	}	
	public void getSex(String sex) {		
	    this.sex =sex;
	}	// 睡觉方法
	public void sleep() {
		System.out.println(this.getName()+"现在"+this.getMonth()+"个月大,它正在睡觉!");
	}
	
}

测试类:

package com.testanimal; // com.testanimal包 
import com.animal.Animal; // 导入 com.animal里面的Animal类
import com.animal.Cat;		// 导入 com.animal里面的Cat类
import com.animal.Dog;		// 导入 com.animal里面的Dog类
public class Test {
	/*
	 * 对象实例化
	 */
	public static void main(String[] args) {		
	// TODO Auto-generated method stub
		Cat cat = new Cat();
		cat.setName("花花");
		cat.setSpecies("小猫猫");
		cat.eat();
		cat.run();
		System.out.println("===================");
		Dog dog =new Dog();
		dog.setName("小狗狗");
		dog.setMonth(15);
		dog.eat();
		dog.sleep();
	}	

}

java的重载和重写方法

1.Java重载:

  • 方法名相同

  • 参数列表不同

  • 访问修饰符无关

  • 返回类型可以修改也可以不修改

  • 方法重载在同一个类中

2.java重写:

  • 有继承关系的子类中

  • 方法名相同,参数列表相同,

  • 方法返回值类型与父类兼容

  • 访问修饰符,访问范围需要大于或者等于父类的访问范围

  • 方法的重写在有继承关系的子类中

  • 声明为final的方法不能被重写。

  • 声明为static的方法不能被重写,但是能够被再次声明。

成员属性:在子类中可以定义和父类重名的属性

Objects中的equals方法

  • 在equals没有被重写时,equals和==都是一样的作用: 都是用来判断两个引用是否在同一个内存地址中。

  • equals被Objects中String重写后,equals的作用就变为判断两个字符串的值是否相等!而==还是判断引用是否在同一个内存地址。

例如:

父类:

package com.animal; // com.animal 包
    /*
     * 私有化属性
     */
    public class Animal {    	
        private String name;   // 名字
    	private  int month;      // 月份
    	private String species;  // 品种
    	/*
    	 * 添加无参构造方法
    	 */
    	public Animal() {
    	
    	}    	
    	//重载带参构造方法
    	public Animal(String name,int month) {    		
    	    this.name=name;    		
    	    this.month=month;
    	}    	
    	public int getMonth() {    		
    	    return month;
    	}    	
    	public void setMonth(int month) {    		
    	    this.month = month;
    	}    	
    	public String getSpecies() {    		
    	    return species;
    	}    	
    	public void setSpecies(String species) {    		
    	    this.species = species;
    	}    	
    	public String getName() {    		
    	    return name;
    	}    	
    	public void setName(String name) {    		
    	    this.name =name;
    	}    
    	// 吃方法
    //	public void eat() {
    //		System.out.println(this.getName()+"在吃东西");
    //	}
    }

测试类

package com.testanimal;          // 导包
import com.animal.Animal;        // 导入 com.animal中的Animal类
/*
 * 父类对象实例化
 */
 public class Test1 {	
 public static void main(String[] args) {		
 // TODO Auto-generated method stub
			Animal one = new Animal("小白",15);
			Animal two = new Animal("小白",15);			
			boolean flag =one.equals(two);
			System.out.println("one和two两个比较为:"+flag); 
			System.out.println("one和 two两个比较为:"+(one==two));			
			String str1 = new String("小白");			
			String str2 = new String("小白");			
			boolean flag2 =str1.equals(str2);
			System.out.println("str1和str2两个的比较为:"+flag2);
			System.out.println("str1和str2的两个比较为:"+(str1==str2));
	}

}

结果:

one和two两个比较为:falseone和 two两个比较为:false

str1和str2两个的比较为:truestr1和str2的两个比较为:false

因为equals被Object方法中被String重写,所以st1.equals(str2)就变为true

  • 类重写equals的方法
    利用类重写equals方法后,判断的就是两个类的值是否相等!而==还是判断引用是否在同一个内存地址。

例如:
父类:

package com.animal; // com.animal 包/*
 * 私有化属性
 */public class Animal {	
        private String name;   // 名字
	private  int month;      // 月份
	private String species;  // 品种
	/*
	 * 添加无参构造方法
	 */
	public Animal() {
	
	}	
	//重载带参构造方法
	public Animal(String name,int month) {		
	    this.name=name;		
	    this.month=month;
	}	
	public int getMonth() {		
	    return month;
	}	
	public void setMonth(int month) {		
	    this.month = month;
	}	
	public String getSpecies() {		
	    return species;
	}	
	public void setSpecies(String species) {		
	    this.species = species;
	}	
	public String getName() {		
	    return name;
	}	
	public void setName(String name) {		
	    this.name =name;
	}	
	// 重写 equals方法
	public boolean equals(Object obj) {		
	        /*
		 * 做逻辑,如果obj这个参数为null,直接返回false,不为空,我们就做下面的判断
		 */
		if(obj==null) 
			return false;		
			// 因为obj是Object类型,这里需要强制转换为Animal类型
		Animal temp = (Animal)obj;		
		// 判断当前属性名字和你传入的名字,同时月份也相同,我们就返回true,不然就返回false
		if(this.getName().equals(temp.getName())&&(this.getMonth()==temp.getMonth())) 
		        return true;	
		else 
			return false;
		
	}	
	// 吃方法
	//	public void eat() {
	//		System.out.println(this.getName()+"在吃东西");
	//	}	
	}

测试类:

one和two两个比较为:trueone和 two两个比较为:false

str1和str2两个的比较为:truestr1和str2的两个比较为:false

还是上面的父类和测试类,这时发现控制台的Aone.equals(two);结果却变为true了!因为equals方法被重写了!

上面的重写obj类是属于Object类的,这样就限制了我们传入数据的数据类型,我们可以利用重载方法来解决这样的问题

public boolean equals(Animal obj) {	
    if(obj==null) 
		return false;	
    if(this.getName().equals(obj.getName())&&(this.getMonth()==obj.getMonth())) 
		return true;	
    else 
		return false;
}
注意:上面不管是重载还是重写方法,判断obj这个参数是否为空,不能省略,避免后面出现异常!

Object中toString方法

  • 返回对象的字符串表示形式。

  • 继承Object中toString方法时,输出的对象格式为:类型信息+@+地址信息

  • 输出对象名时,默认会直接调用类中toString

例如:

System.out.println(one.toString());
  • 子类可以通过重写toString方法的形式,改变输出的内容以及表现形式

  • public String toString() {	
        return "名字:"+this.getName()+"月份:"+this.getMonth();
    }

final

final修饰类,方法,基本类型变量,引用的时候分别有不同的意思。它继承Object这个类, final修饰可以提高性能,但是会降低可扩展性!

  • 修饰类:不能被继承,子类会出现异常错误

    格式:     
                public final class   
    
                final public class
                
          两种格式都可以只要写在class之前
  • 修饰方法:子类不能重写,但是不影响子类调用这个父类派生下来的方法。还是可以被继承者使用的,不能修饰构造方法

  • 修饰成员属性:赋值过程只有三个位置可以赋值:
    1.定义直接初始化
    2.构造方法中赋值
    3.构造代码块中赋值

  • 修饰方法中的局部变量:在定义局部变量可以不赋值,只要被使用之前进行赋值,一旦赋值就不允许再次赋值

  • 修饰引用类型:表示该引用只有1次指向对象的机会,但是对象的内容是可以变的

  • 可以和static关键字使用,来修饰变量,方法,只需要加载一次,后面不准修改的时候就可以用final static这两个搭配

例如:

final Person h;
    h=new Peron();    //再次指向对象就会异常
    h=new Person();   //报错
  • 常量指的是可以公开,直接访问,不会变化的值

注意:如果我们是不能继承Object中的String类,因为String是final的!

多态

同一个事件发生在不同的对象上会产生不同的结果
也可以这样理解 父类引用指向子类对象;

多态就是一个接口有n种实现,但你可以直接用接口调用每个实现的方法

多态的注意事项:

  • 继承关系

  • 重写

  • 父类引用指向子类对象

编译看右边的引用类型,运行看左边的对象类型

向上转型、隐式转型、自动转型:
父类引用指向子类实例,可以调用子类重写父类的方法以及父类派生的方法,无法调用子类独有的方法.
注意:父类中的静态方法无法被子类重写,所以向上转型之后,只能调用父类原有的静态方法

向下转型、强制类型转换:
子类引用转向父类实例
子类引用转向父类实例,必须强制转换,可以调用子类中特有的方法。 必需要能够强制转换,才能转换!

instanceof

判断引用three指向的对象是不是Dog类型,返回 boolean 的数据类型。 返回true和false;

格式:

if(three instanceof Dog) {
			Dog temp3 =(Dog)three;
			temp3.getSex();
		}


Tags: java

很赞哦! (8)

上一篇: 无

下一篇:java中抽象方法和抽象类和接口!

留言

来说点儿什么吧...

您的姓名: *

选择头像: *

留言内容:

    2019年2月25日 13:35嘿嘿

    2019年2月26日 13:20ok

    可以可以!

    2019年3月18日 09:2311

    1

    2019年3月28日 09:24www.ikeguang.com

    可以可以

    2019年5月29日 18:47qwe

    666

    2019年5月30日 16:52BlankYk

    he,tui~

    2019年5月30日 17:04123

    321

    2019年6月26日 10:02周树人

    厉害厉害

    2019年6月26日 10:34sdlakrj

    sdaag

    2019年6月29日 15:31sdagafdbaf

    dgafdgdfh

    站长回复:你这是什么什么高级语言,我表示看不懂哈哈

    2019年7月6日 16:37啦啦

    写的真好!谢谢博主

    站长回复:谢谢!

    2019年8月14日 12:35傻傻

    厉害 小林