面向对象的三大特点以及内部类,选择排序

面向对象三大特点之------封装-private

• 封装的概念
  1>.将类中成员变量私有化,对外提供公共访问方法;
  2>.私有化的成员变量只能在本类中访问,外界不能访问.
• private关键字的特点
  1>.private可以修饰类中的成员变量,也可以修饰成员方法;
  2>.被private修饰的成员变量或者是成员方法只能在本类中访问,外界不能访问(保护数据安全性).
• 将变量定义为成员变量的条件
  如果该变量能够描述一个事物的属性,该变量就要定义为成员变量.
• 构造方法
  1>.方法名与类名相同;
  2>.没有具体返回值;
  3>.没有void;
  表达式:
  权限修饰符 + 方法名(就是类名) (){
  }
  构造方法的作用: 给对象中的数据进行初始化
• 关于静态static的特点
  1>.static 修饰的变量或者方法,随着类的加载而加载
  2>.被static修饰,优先于对象存在
  3>.被static修饰,可以被多个对象共用
  3>.被静态staitc修饰的成员变量或者成员方法可以被类名直接访问;同时也可以用用该类对象来访问.
• 成员方法的访问问题
  1>.非静态的成员方法及可以访问静态成员变量也可以访问非静态成员变量;及可以访问静态成员方法,也可以访问非静态成员方法;
  2>.静态成员方法:静态只能访问静态

面试题

Student s = new Student(); 在内存中做了哪些事情
1.加载Student.class 进内存;
2.在栈内存中开辟栈内存空间;
3.在堆内存中申请空间;
4.对书记进行初始化(成员变量)----先系统默认初始化,然后显式初始化,setXXX(形参)/构造方法赋值;
5.堆内存中申请空间完毕,产生一个堆存地址;
6.将堆内存地址赋值给栈内存变量s;
7.栈内存变量s指向堆内存地址.

面向对象三大特点之------继承-extends

• 继承的概念
  为了访问方便,需要定义独立的类,将其它类中的共性抽取出来,存放在独立类中(父类),从而产生的这中关系称为继承关系.

• 格式
  子类名 extends 父类名()

• 继承的好处
  1>.提高了代码的复用性;
  2>.提高了代码的维护性;
  3>.继承关系是多态的前提条件.

• 继承的特点
  在Java语言中,只支持单继承,不支持多继承,但类与类之间可以多层继承.

• 继承中的注意事项
  1>.子类继承父类,可以继承父类中所有非私有成员,本身私有成员只能在本类中访问,外界无法访问,但可以通过间接方法访问;
  2>.子类继承父类,不能继承构造方法,但可以通过关键字super来访问父类构造方法
  3>.不要为了使用部分功能而去使用继承

• 代码块优先级
  静态代码块 > 构造代码块 > 构造方法

• 方法重写(override)
  在继承关系中子类出现与父类一摸一样方法,子类会将父类的该功能覆盖掉,将这种现象成为方法重写.

• this和super的区别
  this代表当前类对象的地址值引用
  super代表父类空间标识(父类对象的地址值引用)

方法重写(override)和方法重载(overload)的区别

1>.方法重载:方法名相同,参数列表不同,与返回值无关;参数列表不同分为,数据类型不同和参数个数是否相同
		
2>.方法重写:子类出现和父类一摸一样的方法声明:权限修饰符  返回值类型    方法名  形式参数都相同  ,子类该方法还会将父类的方法覆盖掉
		**被final修饰的成员方法不能被重写**

• final关键字的特点

   	1>.可以修饰类,该类不能被继承
   	2>.可以修饰成员变量,此时变量就是常量,如果修饰的是一个基本类型的变量,变量的值不能再改变;如果修饰的是一个引用类型(Student s = new Student() )那么该s对象不能再重新开辟堆内存空间
      3>.修饰成员方法,该方法不能被重写.
  

面向对象三大特点之------多态

• 多态的概念
  一个事物在不同时刻的体现

• 多态的前提条件

   	 	1>.必须存在继承关系
   		2>.方法重写,子类继承父类,将父类功能覆盖掉,使用子类具体功能
   		3>.父类引用指向子类  :父类名   对象名    =    new    子类名();称为向上转型
  

• 成员访问的特点:

   	1>.成员变量:编译没报错,运行看左边;等号左边编译通过,说明父类中存在这个变量,运行看左,访问是父类变量;
  
   	2>.	成员方法:编译报错,运行看右边;等号左边编译通过,运行看右边,子类出现与父类一摸一样的方法;声明(方法重写);
   	
   	3>.	静态成员方法:编译看左,运行看右(静态算不上重写);(静态与类直接相关,随着类的加载而加载);
   	
   	4>.	构造方法:存在继承关系(还是分层初始化;先父类初始化,再子类初始化)
  

• 多态的好处

    1>.提高了代码的复用性(由继承来保证);
    2>.提高了代码的扩展性(由多态来保证).
  

抽象类

• 抽象类概念
  在一个类中,如果该类存在一个功能仅仅方法声明,没有方法体(抽象方法),需要将该类定义为抽象类,必须强制子类重写抽象功能.

• 抽象类特点是什么

   1>.一个类中有抽象方法,那么该类一定是抽象类,如果一个类是抽象类,那它不一定有抽象方法
   2>.抽象类不能实例化(不能创建对象)
   3>.抽象类都需要通过子类实例化(抽象类多态)
  

• 抽象类的成员

   1.成员变量	:即可以定义常量也可以定义变量
   2.成员方法	:即可以定义抽象方法,也可以定义非抽象方法
   3.构造方法	:存在构造方法,无参或者有参对数据进行初始化(分层初始化)
  

接口

• 概念:体现的是事物的一种扩展性功能(本身不具备的,经过学习才具备的功能).

• 接口的注意事项

   1)接口中只能定义抽象方法
   2)接口不能实例化
   3)接口如何实例化呢?
   通过接口的子实现类来进行实例化!
   格式:接口名  对象名  =new 子实现类名();    接口多态!
   接口和子实现类之间的关系:实现关系(implements)
  

• 接口中 成员特点:

   成员方法:
   	只能是抽象方法,存在默认的修饰符,public abstract
   成员变量:
   	只能是常量.存在默认的修饰符:public static final
   构造方法: 
   	不存在构造方法!
  

• 关系区别

   类与类之间:不管这个类是抽象类还是具体类都是(extends)支持单继承,不支持多继承,可以多层继承
   类与接口之间:
   	实现关系(implements)一个类继承另一个类可以实现多个接口
   接口与接口之间:
   	继承关系(extends)
   	支持单继承,以及多继承
  

内部类

• 内部类的概念:在一个类中在次定义另一个类

• 内部内分类

   分为成员内部类和局部内部类.
   成员内部类----类中方法外;局部内部类----成员方法中定义一个类
  

• 如何访问成员内部类

   访问内部类成员格式:
   外部类名.内部类名 对象名  =  new  外部对象().new 内部对象();
  
  
   访问静态成员内部类:
   外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
  

• 局部内部类:

   在外部类的成员方法中定义的类.
  

• 特点:

   1.可以直接访问外部类的所有成员
   2.在外部类的成员方法中,可以通过创建局部内部类对象来访问局部内部类的成员
  

• 局部内部类访问局部变量,局部为什么要加final关键字?

   局部变量的生命周期,随着方法调用而存在,随着方法调用完毕而消失,而当前这个局部变量被局部内部类在进行访问(局部内部类对象进行访问),在堆
   内存中对象不会被立即回收,它还在继续使用这个局部变量,需要将这个变量定义为常量,常驻内存---->以便局部内部类对象对该局部变量的访问!
  

• 匿名内部类

   	格式:
   			new 类(可以是具体类,也可抽象类)名/接口名(){
   					重写方法;
   			};
  

• 匿名内部类的好处:

   不需要创建子类或者子实现类.
  

• 匿名内部类的本质就是

   继承该类或者是实现了该接口的子类对象.
  

Switch选择排序

• 思想特点

   选择排序:
   使用数组的角标0的元素依次往后进行比较,将小的元素往前放,每次比较都会出现一个最小值.依次从小到大排列
  

• 例如

public class Demo{
	
	public static void main(String[] args) {
			//自定义数组
		int[] arr = {57,69,80,24,13} ;
		System.out.println("排序前:");
		array(arr);
		System.out.println("排序之后:");
		array(arr);
	}	
		//遍历数组
	public static void array(int[] arr) {
		//输出左括号[
		System.out.print("{");
		//使用循环
		for(int x = 0 ; x < arr.length ;x++) {
			//判断如果arr[x]的角标是数组的最后一位输出arr[x] 和]
			if(x == arr.length-1) {
				System.out.println(arr[x]+"}");
			}else {
				System.out.print(arr[x]+",");
			}
		}
	}

	public static void switchSort(int[] arr) {
		for(int x = 0 ; x < arr.length-1; x ++) {
			for(int y = x +1 ; y < arr.length ; y ++) {
				//判断:如果后面元素比较前面的元素小,将小的往前放
				if(arr[y] < arr[x] ) {
					int temp = arr[x] ;
					arr[x] = arr[y] ;
					arr[y] = temp ;
				}
			}
		}
	}
}