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

最新推荐文章于 2024-07-10 15:56:53 发布

宅男技术

最新推荐文章于 2024-07-10 15:56:53 发布

阅读量142

点赞数

分类专栏： java全套基础知识

本文链接：https://blog.csdn.net/weixin_44926268/article/details/98346109

版权

java全套基础知识专栏收录该内容

6 篇文章 0 订阅

订阅专栏

#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.反射技术