java全套基础知识第九章面向对象的三大特征

#java全套基础知识第九章面向对象的三大特征#

面向对象的三大特征:
封装:
1.数据隐藏
2.在代码中将相同的代码抽取成方法;
继承:
1.想要拓展一个类的功能,但是不想在本类中拓展,创建新的类继承本类;
2.方法可以覆盖【重写】,成员变量不能覆盖;
多态:
1.继承关系,接口中的实现关系;
2.一个对象具有多种形态【数据类型】;
3.父类引用指向子类对象;

编译看左边,运行看左边;成员变量
编译看左边,运行看右边;成员方法

1.static关键字
0.静态变量又称之为类变量,静态方法称之为类方法;
1.静态数据【变量、方法】被类的所有的对象所共享;
2.由于该变量属于类,所以由类名直接调用;
3.本类对象也可以调用,但是不推荐使用对象调用;
4.静态数据不能访问非静态数据,因为在类被加载的时候,静态数据会随着类的加载而出现,而非静态数据是随着对象的创建而出现;
5.静态代码块:伴随着类的加载而执行,并且只执行一次;
构造代码块:伴随着构造器的执行而执行,并且优先于构造器执行;

练习:分析下面代码的运行结果;
class A{
	static{
		sout("0");
	}

	{
		sout("1");
	}

	A(){
		sout("2");
	}
}

class B exts A{
	static{
		sout("3");
	}

	{
		sout("4");
	}

	B(){
		sout("5");
	}

	main(){
		new B();
		new B();
	}
}

import关键字:在某个类【A类】中如果要使用其他类【类B】的方法,但是类A和类B不在同一个包中,所以需要在类A中使用import关键字引入类B;

package关键字:包,在Java中用于区分同名的类;在物理存储上就是目录路径;

package 包路径;

带包编译:javac -d 目录 Java文件
带包运行:java 包名.类名

2.final关键字
0.意思是最终的,不可修改的;
1.能修饰变量、方法、类;
2.修饰变量时,该变量的值不能再修改,因此该变量也称之为常量;
1.修饰全局变量时,在定义该全局变量的时候就必须指定值【初始化,显式赋值】,并且后面再不能更改该变量的值;
2.修饰局部变量时,在定义时可以不用初始化,但是在第一次使用该变量之前必须初始化,并且后面再不能更改该变量的值;
3.修饰的是引用类型的变量时,该变量引用的内存地址不能更改,但是该变量所指向的对象中的数据可以更改的;
3.修饰方法时,该方法不能被重写;
4.修饰类时,该类不能被继承;【String类】

class Student{
	static final String area="中国";
}

3.访问控制,权限修饰符
【public、default、protected、private】
public:在任意位置都能访问;
protected: 只要不同包就不能访问;
default:只要不同包就不能访问;
private:只能在本类中访问;

4.抽象类和接口
抽象类:
1.在Java中被abstract修饰的类就是抽象类;
2.抽象类中可以有抽象方法【被abstract修饰的方法并且没有方法体】,也可以有普通方法;
3.包含抽象方法的类一定是抽象类;
4.抽象类中也有构造器,但是不能直接创建对象;
5.抽象类只能通过子类继承,创建子类对象来调用该抽象类中的方法;也可以使用匿名内部类的形式;

	abstract class Animal{
		void eat();

		void addWeight(){
			
		}
	}

	class Person extends Animal{
		void eat(){
		
		}
	}

	class Dog{
	
	}

	class Cat{
	
	}
接口:
	0.从Java角度理解,接口就是interface修饰的数据;
		class Student{}
		interface Animal{}
	1.对抽象类的抽象就形成了接口;
	2.接口中的方法全部都是抽象方法,默认由public abstract修饰;但是在JDK8中,接口中可以有普通方法,普通方法只能由default或者static修饰;当一个实现类实现的两个接口中有同名的普通方法时,必须要在该实现类中重写该同名方法;
		
		单一继承
		interface A{
			default void show1(){}
		}

		interface B{
			default void show2(){}
		}

		class C implements A,B{
			main(){
				C c=new C();
				c.show1();
			}
		}

	3.接口中的成员变量全都默认是public static final修饰;
	4.类只能单一继承,接口可以多实现【implement】;
	5.抽象类是is-a关系,接口是like-a关系,组合是has-a关系;
	6.接口中没有构造器,所以只能通过创建新的类实现该接口,然后创建该实现类对象调用接口中的方法;

	interface Animal{
		void eat();
	}

	abstract class TaishengAnimal implements Animal{}

	abstract class LuanshengAnimal implements Animal{}

	class Person extends TaishengAnimal{}

	class Dog implements Animal{}

5.内部类
1.在类内部定义的类,相对应的外面的称之为外部类;
2.成员内部类,在外部类的成员位置定义的类称之为成员内部类;
1.外部类访问内部类中的数据需要创建内部类对象;而要访问内部类对象,则需要先创建外部类对象。
2.内部类可以无条件访问外部类中的成员;

3.静态内部类,在外部类的成员位置定义的类,但是该类被static修饰,所以不是成员内部类,而是静态内部类;
	1.静态内部类只能无条件的访问外部类中的静态资源;
	2.外部类要访问静态内部类中的资源则需要创建内部类对象,但是由于内部类是静态,所以由外部类类名直接调用而不需要创建外部类对象;

4.局部内部类,定义在方法中的或者其他代码块中的类称之为局部内部类;
	1.外部类访问局部内部类中的数据,先创建外部类对象,调用方法,让其先定义内部类,然后在该方法中创建局部内部类对象,然后访问局部内部类中的资源;
	2.局部内部类访问外部类数据,无条件访问;如果局部内部类【静态内部类、成员内部类】中有和外部类或者该局部内部类所处的方法中同名的变量,则外部类和该方法中的变量在局部内部类中会被隐藏。
	3.如果局部内部类中访问到了该局部内部类所处的方法中的局部变量,则该变量必须用为final修饰。但是在JDK8中,该变量可以不显式的使用final修饰,当在局部内部类中调用该变量时,则JVM默认地认为就是final修饰的。

5.匿名内部类,没有名字的内部类,匿名内部类多用于作为实参进行参数传递;通常情况下匿名内部类是借助于抽象类或者接口来使用。

6.==和equals方法
1.两者都用于比较,返回值都是布尔类型的值;
2.==是运算符,equals是Object类【该类是Java体系中所有类的父类】中的方法;
3.==和equals在默认情况下都是比较两个对象的内存地址;
4.当重写了Object类中的equals方法,则会按照重写的规则进行比较;
5.==既能比较基本数据类型也能比较引用数据类型,而equals方法只能比较引用数据类型;
byte 1
boolean 1
short 2
char 2
int 4
float 4
long 8
double 8

	类类型
	接口类型
	数组类型
	枚举类型

abstract class Car{
	abstract void drive();
}


class Teacher{
	void teach(Student s){
		s.study();
	}
	main(){
		Tea t=new Tea();
		// Student s=new Student();
		t.teach(new Student(){
			void study(){
				
			}
		
		});
	}
}


class Student{
	void study(){
	}

	void go(Car c){
		c.drive();
	}
	main(){
		Student s=new Student();
		s.go(new Car(){
			void drive(){
			
			}
		});
	}
}

7.包装器类
1.Java是纯面向对象的语言;
2.包装器类就是Java中的基本数据类型所对应的类类型;
3.自动装箱,JVM将基本数据类型自动的转化为包装器类型;
4.自动拆箱,自动装箱反着来;
5.Java中的整数类型的包装器类,在内存中有一个缓存区,该缓存区中存储了-128到+127这256个整数,当整数包装器类型【类类型,引用类型】所表示值在上述缓存区的范围之内,则直接从该缓存区取值,如果不在上述缓存区范围,则会在堆内存中创建新的对象用于表示该数值;
Integer类---->IntegerCache类,数组
Long类---->LongCache类,数组

	int		Integer
	int x=100;

	Integer z=100;  // 自动装箱

	int tmp=100;
	Integer z=Integer.valueOf(tmp);


	Integer y=100;
	int a=y;

	int a=y.intValue();

	sout(x==z);

Java高级编程2——集合体系
1.集合体系
1.集合本身就是一个对象,用于存储其他对象;
2.集合中只能存储引用类型的数据,不能存储基本类型的数据;当集合中存储基本类型的数据时,JVM会将其自动装箱;
3.集合和数组一样,都可以理解为存储数据的容器;
4.Collection集合:学顶层用底层;在单列集合体系中,Collection接口并不是最顶层接口,该接口有一个父接口:Iterable接口【单列集合的最顶层接口】;
1.Iterator接口:迭代器接口;能够对实现了Iterable接口的集合进行遍历访问【迭代】;

	2.Iterable接口的方法:
		// 获取迭代器对象用于迭代遍历【访问】实现了
		// Iterable接口的集合
		Iterator iterator();
		
	3.Iterator接口中的方法:
		hasNext():	判断有没有下一个元素
		next():	取出下一个元素
		remove():	移除当前获取到的元素

	4.Collection接口中的方法:
		add(Object o);		添加元素到集合尾部
		remove(Object o);	移除元素
		size();				获取元素个数
		clear();			清空集合

	5.List接口,该类集合表示有序【向集合中添加元素的顺序和从集合中取出元素的顺序是一致的】可重复的集合,并且集合中的元素可以为null;
		add(int index,Object o);	// 在指定位置添加元素
		remove(int index);			// 移除并返回指定位置上的元素
		set(int index,Object o);	// 修改指定位置的元素
		get(int index);				// 获取指定位置上的元素

	6.ArrayList类:List集合的具体实现,底层的实现原理是可变长的数组;数组中只能添加同一类型的元素,集合在没有指定泛型的情况下可以添加任意引用类型的数据;
		
	7.List集合元素的迭代遍历:
		1.通过索引遍历:
			集合的索引最小值是0,最大值是size-1;

		2.增强for循环遍历:
			for(Object o : list){
			}
		3.迭代器遍历:

		4.JDK8中的Lambda表示遍历:

2.增强for循环【foreach/forEach】

3.泛型

4.枚举【enum/Enum】

5.反射技术

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值