关闭

死亡笔记1---java语言的四大特性以及方法重载 方法重写的区别以及new创建对象所用到的知识点

标签: java基础
241人阅读 评论(0) 收藏 举报
分类:

一 :开发:其实就是找对象使用,没有对象就创建一个对象..

找对象--(建立对象)-使用对象-维护对象的关系


java语言的第一特性:封装

什么是封装? 

public class User {
	private String nameId;
	private String passw;
	private String sex;
	private String date;
	
	public User() {
		super();
	}

	public User(String nameId, String passw, String sex, String date) {
		super();
		this.nameId = nameId;
		this.passw = passw;
		this.sex = sex;
		this.date = date;
	}

	public String getNameId() {
		return nameId;
	}

	public void setNameId(String nameId) {
		this.nameId = nameId;
	}

	public String getPassw() {
		return passw;
	}

	public void setPassw(String passw) {
		this.passw = passw;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getDate() {
		return date;
	}

	public void setDate(String date) {
		this.date = date;
	}

	@Override
	public String toString() {
		return "用户 [nameId=" + nameId + ", passw=" + passw + ", sex=" + sex
				+ ", date=" + date + "]";
	}
	 
}

封装就是将变化隔离

封装后的代码便于使用

提高代码的复用性

提高了安全性

封装的原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共的方法对其访问.

这个原则说的通俗一点:表现在程序中,就是把属性私有化,将方法公开化..


java语言的第二特性:继承

什么是继承?

public abstract class Animal {
	public String name;
	public int age;
	public Animal(){
		super();
	}
	public abstract void eat();
	
}



public class Dog extends Animal{
	public Dog(){
		
	}
	public Dog(String name,int age){
		this.name=name;
		this.age=age;
	}
	@Override
	public void eat(){
		System.out.println("狗吃骨头..");
	}
}

把多个类中相同的成员给提取出来定义到一个独立的类中.然后让这多个类和该独立的类产生一个关系.这多个类就具备了这些内容,这个关系叫继承.

子类继承父类,子类拥有父类的特性,同时子类拥有自己的个性..而且继承也是多态的前提. 所有类的基类都是Object.

继承的关键字是:extends

格式:

 class 子类名 extends 父类名{}

继承的好处:提高了代码的复用性   提高了代码的维护性  让类与类产生了一个关系,是多态的前提

继承的弊端:让类的耦合性增强. 这样某个类的改变,就会影响其他的和该类相关的类.   打破了封装性

开发的原则:低耦合,高内聚

耦合:类与类的关系

内聚:自己完成某件事情的能力

java中继承的特点:java中类只支持单继承  java中可以多层(多重)继承

继承需要注意的事项:

子类不能继承父类的私有成员

子类不能继承父类的构造方法,但是可以通过surper去访问 

不要为了部分功能而去继承

子类的构造方法默认回去访问父类的无参构造


java语言的第三特性:多态

什么是多态?

	public static void main(String[] args){
                Animal an=new Dog();	
                an.eat();
		Animal an=new Cat();
		an.eat();
		
	}

输出结果:
狗吃骨头...
猫吃鱼...

同一个对象在不同时刻体现出来的不同状态

父类的引用指向了自己的子类对象

父亲的引用也可以接受自己的子类对象

多态的前提:有继承或者实现关系

有方法重写

有父类或者父接口引用指向子类对象

多态可分为:具体类多态 抽象类多态 接口多态

多态的好处:提高了代码的维护性(继承体现)  提高了代码的扩展性(多态体现)

多态的弊端:父不能使用子类的特有功能

现象:子可以当做父使用,父不能当做子使用

多态中的转型:

向上转型:从子到父

向下转型:从父到子

注意:千万不要将父类对象转换成子类类型,多态自始至终都是子类对象在做着变化


java语言的第四特性:抽象

把多个共性的东西提取到一个类中,这是继承的做法

但是呢,这多个共性的东西,有些时候,方法签名一样,但是方法体不同

也就是说,方法声明一样,但是每个具体的对象的对象在具体实现的时候内容不一样

所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体

而一个没有具体的方法体的方法就是抽象方法

在一个类中如果有抽象方法,该类必须定义为抽象类


抽象类的特点:

抽象类和抽象方法必须用关键字abstract修饰

抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

抽象类不能实例化

抽象类的子类:1是一个抽象类 2是一个具体类,这个类必须重写抽象类中的所有抽象方法

关于抽象类的几个小总结:

抽象类有构造方法,但是不能被实例化,那么构造方法有什么用?

用于子类访问父类数据的初始化

一个类如果没有抽象方法,却定义为了抽象类,有什么用?

为了不让创建对象

abstract不能和哪些关键字共存?

final冲突

private 冲突

static 无意义


二: Override和Overload的区别:

方法重载:

方法的名称相同

不以返回值区分

参数的个数 类型 顺序其一不同即可

重写:

发生在子父类之间

要求方法签名一样(返回值类型 方法名和参数列表一样,子类的方法访问权限必须大于等于父类)



  三:new一个对象,都做了那些事情?

eg: Person p=new Person("张三",21);

1 因为new用到了Person.class,所以会先找到Person.class文件,并加载到内存中

2执行该类的static代码块,如果有的话,给Person.class进行初始化

3在堆内存中开辟空间,分配内存地址

4在堆内存中建立对象的特有属性,并进行默认初始化

5对属性进行显初始化

6对对象进行构造代码块初始化

7对对象进行构造函数初始化

8将内存地址赋给栈内存的p变量

创建对象完成...




0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:620次
    • 积分:44
    • 等级:
    • 排名:千里之外
    • 原创:4篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档