【黑马程序员】java中--------------封装、继承、多态

最新推荐文章于 2022-06-07 13:04:21 发布

天下xu

最新推荐文章于 2022-06-07 13:04:21 发布

阅读量663

点赞数

分类专栏： java学习日记

本文链接：https://blog.csdn.net/u011079455/article/details/13775189

版权

java学习日记专栏收录该内容

26 篇文章 0 订阅

订阅专栏

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

封装

类：类就是用来描述事物的属性（成员变量）和行为（成员方法）。

对象：对象就是这类事物，实实在在存在的个体。

类与对象的关系：通过new这类事物就可以将这类事物封装为对象，通过对象的引用就可以调用类中的成员变量和成员方法

成员变量与局部变量：

A.成员变量：作用于整个类；内存位置是在堆内存中，因为对象的存在而存在

B.具部变量：作用于函数中，或者语句中；且存在于栈内存中

匿名对象：当对象的方法值只调用一次时，可以用匿名对象来完成，这样比较简化

可以将匿名对象作为实际参数进行传递

面向对象（封装）

封装：就是指隐藏随性的属性和实现细节，对外仅仅提供公共的访问方式。

好处：将变化隔离；便于使用；提高重用性；提高安全性

原则：将不需要对外的内容隐藏起来；

把属性都隐藏，对外提供公共方法。

Private; set (); get ();

构造函数：对象一建立就会调用与之对应的构造函数；作用是用于给对象进行初始化。

本身具有默认构造函数：类名（）{}；

构造代码块：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行

区别：构造代码块是给所有对象进行统一初始化；可以将不同对象共性的内容抽取该区域。

而构造函数是给对应的对象初始化

Class person{
private String name;
Private int age;
Person(String name,int  age){
Name=name;
　　Person(String name,int  age){
　　Name=name;
　　Age=age;
　　}
　　{
　　System.out.println(“哭..........................”);
　　}
}
Class personDemo{
　　Mian(){
　　Person  p=new person();
　　}
}

(this: 代表本类对象，代表它所在函数所属对象的引用。

效果：看上去是用于区分局部变量和成员变量同名情况

构造函数间的调用：this( );函数调用函数，只能在构造函数的第一行

注意：一般函数是不能调用构造函数，

/static 关键字（只能修饰成员方法和成员变量）；4.无需建立对象：直接类名调用

特点：1.随着类的加载而加载（周期过长）；2. 优先于对象存在；3. 被所以对象所共享

内存位置：随着类加载存于方法区域中；随着类的消失而消失

一般变量：存在于堆内存中；随着对象的垃圾回收而消失

注意：静态方法只能访问静态成员

非静态方法可以访问静态和非静态

2；静态方法中不能有this super 关键字。以为静态优先于对象存在

Day6 main函数（作为程序的入口）

静态变量的应用：当对象出现共享数据时可以定义

静态函数：当功能内部没有服务到静态数据（对象的特有数据）

那么该功能方法可以定义成静态

例子：如工具类

指定路径查找：set classpath=.;c:\myclass 点是当前路径，+指定路径

帮助文档制作：

/**

@auther :作者

@version :版本号

方法上面@param arr 参数接收一个int类型的数组

@return 会返回一个该数组中的最大值

编译时，指定文档的存放位置：javadoc -d (E:\myclass)或者当前maclass -auther -version 类名.java

注意:构造函数的权限随着类的改变而改变

静态代码块：static {静态代码块中的执行语句}

特点：随着类的加载而执行，只执行一次。用于给类进行初始化

构造代码块：{ 执行语句}是给所有对象初始化，随着对象的建立而初始化

类一加载：静态代码块 >构造代码块 >Static静态方法

继承：day7

1，提高代码的复用性 2，让类与类之间存在了关系，有了这个关系才有了多态的特性

例子;经理类

class Emplouyee{
	private String name;
	private String id;
	private double pay;
	Emplouyee(String name,String id,double pay){
		this.name=name;
		this.id=id;
		this.pay=pay;
	}
	public void work();
}
class Manager extends Employee{
	private int bonus;
	Manager(String name,String id,double pay,int bonus){
		super(name,id,pay);
		this.bonus=bonus;
	}
	public void work(){
		System.out.println("经理开始工作：");
	}
}
class Pro extends Employee{
	Pro(String name,String id,double pay){
		super(name,id,pay);
	}
	public void work(){
		System.out.println("普通员工开始工作：");
	}
}
class JiChengDemo{
	public static void main(String[] args){
		Manager m=new Manager();
		m.work();
	}
}

抽象类：abstract

例子：模板设计模式；类与抽象类是继承关系

定义：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而却定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，有该类的子类去完成。

需求：获取一程序运行的时间。

abstract class GetTime{
	public final void getTime(){
		long start=System.currentTimeMillis();
		runCode();
		long end=System.currentTimeMillis();
		System.out.println("毫秒值："+(end-start));
	}
	public abstract void runCode();
}
class SubTime extends GetTime{
	public void runCode(){
		for(int x=0;x<4000;x++){
			System.out.print(x);
		}
	}
}
class GetTimeDemo{
	public static void main(String[] args){
		SubTime st=new SubTime();
		st.getTime();
	}
}

接口：interface

类与接口是实现关系（implements）

特点：接口中常见定义；常量，抽象方法。

接口中的成员都有固定的修饰符

Public static final --

Public abstract --

接口可以被多实现，

接口与接口直接可以多继承，但其中的方法一定是一模一样的，否则在调用方法时不明确

多态：

体现：父类的引用指向直接的子类对象，父类的引用页可以接受直接的子类对象

前提：必须是类与类之间有关系，要么继承，要么实现，另外；还存在覆盖

多态的好处：多态的出现大大的提供程序的扩展性、

多态的应用：animal 的例子和主板示例 instanceof 判断所属类型

还有就是object类，equals()方法 toString()方法

abstract class Animal{
	public abstract void eat();
}
class cat extends Animal{
	public void eat(){
		System.out.println("吃鱼！！");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");			
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("吃屎！！");
	}
	public void kanjia(){
		System.out.println("看万秀云");
	}
}
class Pig extends Animal{
	public void eat(){
		System.out.println("吃饲料！！");
	}
	public void gongDi(){
		System.out.println("翻地");
	}
}
class duotai1{
	public static void main(String[] args){
		//Animal a=new cat();//类型提升，向上转型
		//a.eat();	
		//cat c=(cat)a;//强转父类引用，父转子，向下转型
		function(new cat());
		//c.catchMouse();
		function(new Dog());
		function(new Pig());
	}
	public static void function(Animal a){
		a.eat();
		if(a instanceof cat){
		   cat c=(cat)a;
		   c.catchMouse();
		}
		else if(a instanceof Dog){
			Dog c=(Dog)a;
			c.kanjia();
		}
		else if(a instanceof Pig){
			Pig c=(Pig)a;
			c.gongDi();
		}
	}
	 
}

Day9 : 内部类

规则：1，内部类可以直接访问外部类中的成员（包括私有成员）；；原因是内部类有外部类的引用：类名.this

2，外部类要访问内部类，必须建立内部类对象

内部类在成员位置上：可以private ,static修饰

在局部位置的内部类：如果局部的变量被final y=8;修饰，局部内部类的方法才可以访问

public class Demo1{
	public static void main(String[] args){
		Outer o=new Outer();
		
		o.function();
		
	}
}
class Outer{
	private int x=3;
	public void function(){
		final int y=8;	
		 class Inner1{
			public void show(){
				
				  
			//内部类访问外部类成员，带外部类引用this
				System.out.println("内部类1:"+Outer.this.x);
				System.out.println("内部类1:"+y);
			}
			
		}
		 Inner1 i=new Inner1();
			i.show();
	}
}

在外部类中定义一个匿名内部类：前提是他有一个父类（包括继承extends或实现implements）

天下xu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【黑马程序员】java中--------------封装、继承、多态

面向对象；(封装，继承，多态)类：类就是用来描述事物的属性（成员变量）和行为（成员方法）。对象：对象就是这类事物，实实在在存在的个体。类与对象的关系：通过new这类事物就可以将这类事物封装为对象，通过对象的引用就可以调用类中的成员变量和成员方法成员变量与局部变量：A.成员变量：作用于整个类；内存位置是在堆内存中，因为对象的存在而存在B.具部变量：作用于函数中，或者语
复制链接

扫一扫