面向对象学习

面向对象与面向过程的区别

面向过程思想适合简单、不需要协作的任务，

面向对象需要很多协作才能完成，面向对象就应运而生了。

object（对象），instance（实例）

都是解决问题的思维模式，都是代码组织的方式
解决简单问题可以使用面向过程
解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

对象是什么，对象和数据管理

事物的发展总是遵循“量变引起质变”的哲学原则，起初是并不需要对象的，

数据无管理时代：不做任何管理
数据管理和企业部门制：因此有了数组的概念
对象和企业项目制：项目组合一个独立的公司差不多，例如腾讯微信组

对象是包含了不同类型的数据

对象和类的关系、属性、成员变量、方法

对象和类的概念

类（class）可以看做是对象的模板

抽象是抽出像的部分形成一个类，某个类的对象，某个类的实例是一样的意思。

类中包括属性（成员变量）和方法，

只有属性没有方法，只能叫做结构体。

一个典型类的定义和类的UML图

看到new " " 就代表创建一个对象

构造方法，用于创建这个类的对象，无参的构造方法可以由系统自动创建

UML图直观的表示一个类的结构。

内存分析

Java虚拟机的内存可以分为三个区域，栈（stack），堆(heap)、方法区（method area），方法区也在堆中

栈

栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等)
JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）
栈属于线程私有，不能实现线程间的共享！
栈的存储特性是“先进后出，后进先出”
栈是由系统自由分配，速度快！栈是一个连续的内存空间。

堆

堆用于存储创建好的对象和数组（数组也是对象）
JVM 只有一个堆，被所有线程共享
堆是一个不连续的空间，分配灵活，速度慢

方法区

JVM只有一个方法区，被所有线程共享。
方法区实际也是堆，只是用于存储类、常量相关的信息！
用来存放程序中永远是不变或唯一的内容。（类信息，class对象、静态变量、字符串常量等）

构造方法

构造器也叫构造方法，用于对象的初始化

构造方法的第一句总是super，即使不书写，编译器也会自动添加

要点：

通过new关键字调用
构造器虽然有返回值，但是不能定义返回值类型（返回值的类型肯定是本类），不能在构造器里面使用return返回某个值
如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数，如果已定义则编译器不会自动添加！
构造器的方法名必须和类名一致。

return作用：1. 结束方法运行，

返回值。

垃圾回收机制

发现无用的对象。
回收无用对象占用的空间。

垃圾回收相关算法

引用计数法：缺点是循坏引用的无用对象，无法被识别
引用可达法（根搜索算法）：较为常用。

通用的分代垃圾回收机制

年轻代、年老代、持久代

等学到一定程度 ——回看067 开发中容易造成内存泄漏的操作。

this关键字

对象创建的过程

分配对象空间，并将对象成员变量初始化为0或为空
执行属性值的显示初始化
执行构造方法
返回对象的地址给相关的变量

this的本质

就是创建好的对象的地址，由于在构造方法调用前，对象已经创建，因此，在构造方法中也可以使用this代表当前对象。

构造器的调用只能位于第一列

this不能用于static方法中 ，this指的是当前对象

static关键字

static ‘静态’的意思，用static声明的成员变量为静态成员变量，也称为类变量，类变量的生命周期和类相同，在整个应用程序执行期间都有效

static修饰的成员变量和方法，从属于类

普通变量和方法从属于对象

静态方法无法使用非静态的方法。

静态方法可以使用静态变量

把普通与静态看做汽车和汽车的设计图纸作比加深理解。普通方法可以调用静态方法，好比有汽车必有图纸。

静态初始化块（讲完继承回头再看一遍）

静态初始化块用于类的初始化。

继承树的追溯

参数传值机制

Java中所有参数传值都是值传递，也就是传递的值的副本，传递的是地址的拷贝

public class test {public static void main(String[] args) {User4 u1=new User4(100,"高小七");u1.testParameterTransfer01(u1);System.out.println(u1.name);}public static class User4{int id;String name;String pwd;public User4(int id,String name){this.id = id;this.name=name;}public  void testParameterTransfer01(User4 u){u.name="高小八";}}
}

Java包机制

包机制是Java中管理类的重要手段。开发中，我们会遇到大量同名的类，通过包我们很容易对解决类重名的问题，也可以实现对类的有效管理，包对于类，相当于文件夹对于文件的作用。

包名位于第一句，一定是非注释性的语句。

import详解

静态导入

加*代表导入所有类。

面向对象三大特征

继承

继承（extends),子类是父类的拓展，

Java中只有单继承，Java的接口可以多继承

子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问，比如，父类私有的属性和方法。

方法的重写override

子类通过重写父类的方法，可以用自身的行为替换父类的行为

方法重写的要点：

==：方法名，形参列表相同
“<=”:返回值类型和声明异常类型，子类小于等于父类
“>=”：访问权限，子类大于父类

object类的用法

object类时所有Java类的根基类，也就意味着所有的Java对象都拥有object类的属性和方法。

super关键字

super是直接父类对象的引用，可以通过super来访问父类中被子类覆盖的方法或属性

构造方法的调用顺序

构造方法的第一句总是super（），是默认的。，所以，流程是：先向上追溯带object。然后在依次向下执行类的初始化和构造方法，知道当前子类为止。
静态初始化块的调用顺序，与构造方法调用顺序一样。

封装的作用和含义

程序设计追求的是“高内聚，低耦合”，高内聚就是内部数据操作自己完成，不允许外部干涉，低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用

封装的优点：

提高代码的安全性
提高代码的复用性
高内聚：粉转细节，便于内部修改代码，提高可维护性
低耦合：简化外部调用，便于调用者使用，便于拓展和协作

封装的实现—使用访问控制符

private表示私有，只有自己类能访问
default表示没有修饰符修饰，只有同一个包的类能访问
protected表示可以被同一个包的类以及其他包中的子类能访问
public表示可以被该项目的所有包中的所有类访问

（子类不可以引用父类的私有属性和方法）

封装的使用细节

类的属性的处理：

一般使用private访问的权限
提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作（注意：Boolean变量的get方法是is开头的）
一些只用与本类的辅助性方法可以用private修饰，希望其他类所使用的方法用public修饰。

多态

多态指的是同一个方法的调用，由于对象不同可能会有不同的行为，现实生活中，同一个方法，具体实现会完全不同。

多态的要点

多态是方法的多态，不是属性的多态（多态与属性无关）
多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象
父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

对象的转型

自动向上转型：子类可以自动转型为父类

强制向下转型，可以将父类的对象转为子类（自上而下）

UNStudent st2=(UNStudent) st1;

强制转型转化后父类可以调用子类中特有的方法

子类的对象转为父类（自下而上）是自动转型。

final关键字

修饰变量：被修饰的变量不可改变，一旦赋了初值，就不能被重新赋值
修饰方法：该方法不可被子类重写，但是可以被重载
修饰类：修饰的类不可被继承，比如Math,String。

数组

数组是相同类型数据的有序集合，数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称做一个元素，每个元素可以通过一个索引（下标）来访问它们。

基本特点：

长度是确定的，数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型
数组类型可以是任意数组类型，包括基本数据类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组的初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

静态初始化

int[] a = {3, 4, 5};//静态初始化

默认初始化

int a2[]=new int[2];//默认初始化

动态初始化

int []a1=new int[2];
a1[0]=1;
a1[1]=2;//动态初始化

数组的遍历

public class test {public static void main(String[] args) {int []a =new int[4];for (int i= 0;i<a.length;i++){a[i]=100*i;}for (int i = 0;i<a.length;i++){System.out.println(a[i]);}}
}

for-each循环

专门用于读取数组或集合中所有的元素，即对数组进行遍历

for (int m :a){System.out.println(m);
}

数组的拷贝

public static void testBsaicCopy(){String [] s1 = {"aa","bb","cc","dd","ee"};System.arraycopy(s1,3,s1,3-1,s1.length-3);s1[s1.length-1] = null;for (int i = 0; i<s1.length;i++){System.out.println(i+""+s1[i]);}}

数组的扩容

//数组的扩容（本质上是：先定义一个更大的数组，然后将原数组内容拷贝到新数组中）public static void extendRange(String[]s1){//String[]s1={"aa","bb","cc"};String[]s2=new String[s1,0,s2,0,s1.length];for (String temp:s2){System.out.println(temp);}}

Arrays类

是一个工具类

public class TestArrays {public static void main(String[] args) {int[]a={100,20,35,5,50,80};System.out.println(a);//打印指定的数组内容System.out.println(Arrays.toString(a));Arrays.sort(a);System.out.println(Arrays.toString(a));System.out.println(Arrays.binarySearch(a,35));}}

多维数组

可以看成以数组为元素的数组

int[][] a=new int[3][];a[0]=new int[]{20,30};a[1]=new int[]{10,15,80};a[2]=new int[]{50,60};System.out.println(a[1][2]);//静态初始化二维数组int b [][]={{20,30,40},{50,20},{100,200,300,400}};System.out.println(b[2][3]);}

数组存储表格数据

Object[] emp1 = {1001, "李文泽", "学生", "2001-12-03"};Object[] emp2 = {1002, "李文泽", "学生", "2003-04-03"};Object[] emp3 = {1003, "李文泽", "学生", "2009-05-03"};Object[][] tableData = new Object[3][];tableData[0] = emp1;tableData[1] = emp2;tableData[2] = emp3;for (Object[]temp:tableData){System.out.println(Arrays.toString(temp));}

冒泡排序优化排序

算法如下:

比较相邻的元素，如果第一个比第二个大，就交换他们两个
对每一对相邻元素作相同的工作，从开始第一对到结尾的最后一对，在这一点，最后的元素应该会是最大的数
针对所有的元素重复以上的步骤，除了最后一个
持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较

基本算法

public class TestBubbleSort {public static void main(String[] args) {int[] values = {3, 1, 6, 2, 9, 0, 7, 4, 5, 8};int temp = 0;for (int i = 0; i < values.length - 1; i++) {for (int j = 0; j < values.length - 1-i; j++) {if (values[j] > values[j + 1]) {temp = values[j];values[j] = values[j + 1];values[j + 1] = temp;}System.out.println(Arrays.toString(values));}System.out.println("***************");}}
}

优化算法

public class TestBubbleSort {public static void main(String[] args) {int[] values = {3, 1, 6, 2, 9, 0, 7, 4, 5, 8};int temp = 0;for (int i = 0; i < values.length - 1; i++) {boolean flag=true;for (int j = 0; j < values.length - 1-i; j++) {if (values[j] > values[j + 1]) {temp = values[j];values[j] = values[j + 1];values[j + 1] = temp;flag=false;}System.out.println(Arrays.toString(values));}if (flag){System.out.println("结束");break;}System.out.println("***************");}}
}

二分法查找（折半检索）

基本要求：数组要排好序

//测试二分法查找
public class TestBinarySearch {public static void main(String[] args) {int[] arr = {30, 20, 50, 10, 80, 9, 7, 12, 100, 40, 8};Arrays.sort(arr);int value = 10;System.out.println(Arrays.toString(arr));System.out.println(myBinarySearch(arr,40));}
public static int myBinarySearch(int []arr, int value){int low=0;int high=arr.length-1;while (low<=high){int mid=(low+high)/2;if (value==arr[mid]){return mid;}if (value>arr[mid]){low=mid+1;}if (value<arr[mid]){high=mid-1;}}return -1;
}
}

抽象类、抽象方法

抽象方法

使用abstract修饰的方法，没有方法体，只有声明，定义的是一种“规范”，就是告诉子类必须要给抽象方法听过具体的实现

抽象类

包含抽象方法的类就是抽象类，通过abstract方法定义规范，然后要求子类必须定义具体实现（必须重写），通过抽象类，我们就可以做到严格限制子类的设计，是子类之间更加通用

使用要点

有抽象方法的类只能定义成抽象类
抽象类不能实例化，即不能用new来实例化抽象类
抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用
抽象类只能用来被继承
抽象方法必须被子类实现

抽象类的意义就在于：为子类提供统一的、规范的模板，子类必须实现相关的抽象方法。

接口

接口是比“抽象类”更抽象的“抽象类”，接口的本质是契约

定义接口的说明：

访问修饰符：只能是public或者默认default
接口名：和类名采取相同的命名机制
extends:接口可以多继承
常量：接口中的属性只能是常量，总是：public static final 修饰，不写也是
方法：接口中的方法只能是：public abstract，省略的话，也是public abstract。

要点

子类通过implements来实现接口中的规范
接口不能创建实例，但是可用于声明变量了类型
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的
JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、普通方法、构造方法

内部类

成员内部类

成员内部类包含非静态内部类和静态内部类

非静态内部类

非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问内部类的成员。

非静态内部类必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象，那么一定存在对应的外部类对象，非静态内部类对象单独属于外部类的某个对象
非静态内部类可以直接访问外部类成员，但是外部类不能直接访问非静态内部类成员
非静态内部类不能有静态方法，静态属性和静态代码块
外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例

成员变量访问要点

内部类里方法的局部变量：变量名
内部类属性：this.变量名
外部类属性：外部类名.this.变量名。

静态内部类

用static修饰

使用要点

当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法
静态内部类看做外部类的一个静态成员，因此，外部类的方法可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过new 静态内部类（）访问静态内部类的实例。

匿名内部类

注意：

匿名内部类没有访问修饰符
匿名内部类没有构造方法，因为没有名字

局部内部类

方法内部定义的，作用域只限于本方法，成为局部内部类

string类

string类称作不可变序列
Java字符串就是Unicode字符序列
比较字符串使用equals（），不要使用==

StringBuilder(可变字符串序列)

String str;//StringBuilder线程不安全，效率高（一般使用它）；StringBuffer线程安全，效率低StringBuilder sb =new StringBuilder("abcdefg");System.out.println(Integer.toHexString(sb.hashCode() ));System.out.println(sb);sb.setCharAt(2,'M');System.out.println(Integer.toHexString(sb.hashCode()));System.out.println(sb );

StringBuilder sb =new StringBuilder();for (int i=0; i<26;i++){sb.append((char)('a'+i));}System.out.println(sb);sb.reverse();//倒序System.out.println(sb);sb.setCharAt(3,'高');System.out.println(sb);sb.insert(0,'我').insert(6,'爱').insert(10,'你');//链式调用。核心就是：该方法调用了return this，把自己返回了。System.out.println(sb);sb.delete(20,23);System.out.println(sb)

注意

/*使用String进行字符串的拼接*/String str ="";long num1=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间long time1=System.currentTimeMillis();for (int i=0;i<500;i++){str = str+i;}long num2=Runtime.getRuntime().freeMemory();long time2=System.currentTimeMillis();System.out.println("String占用内存："+(num1-num2 ));//975256System.out.println("String占用时间："+(time2-time1));//17ms/*使用StringBuilder进行字符串的拼接*/StringBuilder sb1=new StringBuilder("");long num3=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间long time3=System.currentTimeMillis();for (int i=0;i<500;i++){sb1.append(i);}long num4=Runtime.getRuntime().freeMemory();long time4=System.currentTimeMillis();System.out.println("StringBuilder占用内存："+(num4-num3));//0System.out.println("StringBuilder占用时间："+(time4-time3));//0

建议使用stringbuilder进行循环拼接。

常量池

全局字符串常量池
class文件常量池
运行时常量池

包装类

包装类位于Java.lang包

//Integer a = new Integer(3);//基本数据类型转化为包装类对象Integer a=new Integer(3);Integer b=Integer.valueOf(30);//把包装类对象转成基本数据类型int c =b.intValue();double d =b.doubleValue();//把字符串转成包装类对象Integer e = new Integer("9999");Integer f = new Integer("999888");//把包装类对象转化成字符串String str = f.toString();//""+f也可以//常见的常量System.out.println("int类型最大的整数"+Integer.MAX_VALUE);System.out.println("int类型最小的整数"+Integer.MIN_VALUE);

自动装箱和拆箱

自动装箱：基本类型的数据处于需要对象的环境中时，会自动转为“对象”

自动拆箱：每当需要一个值时，对象会自动转成基本数据类型，不需要再去显式调用intValue()、doubleValue()等转型方法

Integer a=234;//编译器会转化为 Integer a =Integer.valueOf(234)   自动装箱int b =a;  //编译器会修改成int b =a.intValue()  自动拆箱Integer c= null;if (c!=null){int d =c;   //自动拆箱，调用了：c.intValue}//缓存【-128,127】之间的数字,实际就是系统初始的时候，创建了【-128,127】之间的一个缓存数组//当我们调用valueOf（）的时候，首先检查是否在【-128,127】之间，如果在这个范围之间直接从缓存数组中拿出已经建好的对象//如果不在这个发范围，则创建新的Integer对象。Integer in1= -128;Integer in2= -128;System.out.println(in1==in2);//true，因为在缓存范围内System.out.println(in1.equals(in2));//trueInteger in3=1234;Integer in4=1234;System.out.println(in3==in4);//false，因为1234不在缓存范围内System.out.println(in3.equals(in4));//true

DATE 时间类

1970年1月1日 00：00：00定为基准时间

Java中使用long类型的变量来表示时间，

 Date d =new Date(2000);System.out.println(d);System.out.println(d.getTime());Date d2 = new Date();System.out.println(d2.getTime());System.out.println(d2.after(d));//以后遇到日期处理，使用Canlendar日期类Date d3 = new Date(2020-1900,3,10);System.out.println(d3);//2020.4.10

DataFormat 类和 SimpleFormat 类

//把时间对象按照“格式字符串指定的形式”转成相应的字符串DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");String str = df.format(new Date(4000000));System.out.println(str);//把字符串按照“格式字符串指定的格式”转成相应的时间对象DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");Date date = df.parse("1983-5-10 10:45:59");System.out.println(date);//测试其他的字符,利用D，或者获得本时间对象是所处年份的第几天DateFormat df3 = new SimpleDateFormat("D");String str3= df3.format(new Date());System.out.println(str3);

Calendar和GregorianCalendar的使用

Calendar calendar = new GregorianCalendar(2999,10,9,22,10,50);int year=calendar.get(Calendar.YEAR);int month=calendar.get(Calendar.MONTH);int weekday = calendar.get(Calendar.DAY_OF_WEEK);//星期几：1-7.1：星期日，2：星期一，7：星期六int day=calendar.get(Calendar.DATE);//也可以使用DAY_OF_MONTH.System.out.println(year);System.out.println(month);//0-11表示对应的月份，0是一月，依此类推。System.out.println(weekday);System.out.println(day);//设置日期相关的元素Calendar calendar1=new GregorianCalendar();calendar1.set(Calendar.YEAR,8012);System.out.println(calendar1);//日期的计算Calendar calendar2 =new GregorianCalendar();calendar2.add(Calendar.YEAR,-100);System.out.println(calendar2);//日期对象和时间对象的转化Date date = calendar2.getTime();Calendar calendar3 = new GregorianCalendar();calendar3.setTime(new Date());printCalendar(calendar3);}public static void printCalendar(Calendar c){int year = c.get(Calendar.YEAR);int month = c.get(Calendar.MONTH)+1;int date = c.get(Calendar.DAY_OF_MONTH);int dayWeek = c.get(Calendar.DAY_OF_WEEK)-1;String dayWeek1=dayWeek==0?"日":dayWeek+"";int hour =c.get(Calendar.HOUR);int minute=c.get(Calendar.MINUTE);int second=c.get(Calendar.SECOND);System.out.println(year+"年"+month+"月"+date+"日  "+hour+"时"+minute+"分"+second+"秒"+ "   周"+dayWeek);

File类

import java.util.Date;
import java.util.Objects;
import java.util.Properties;
import java.util.Scanner;public class test {public static void main(String[] args) throws IOException {File f = new File("d:\\a.txt");File file =new File("d:/a.txt");file.createNewFile();System.out.println("File是否存在"+file.exists());System.out.println("File是否是目录"+file.isDirectory());System.out.println("File是否是文件"+file.isFile());System.out.println("File最后修改的时间"+new Date(file.lastModified()));System.out.println("File的大小"+file.length());System.out.println("File的文件名"+file.getName());System.out.println("File的目录路径"+file.getAbsoluteFile());//使用mkdirs和mkdir创建目录File file1 =new File("d:/电影/华语/大陆");boolean flag = file1.mkdirs();//目录结构中有一个不存在也没关系，创建整个目录树System.out.println(flag);//File类综合运用File file2 = new File("d:/sxt/b.txt");boolean flag1=file2.exists();if (flag1){boolean flagd = file2.delete();if (flagd){System.out.println("删除成功");}else {System.out.println("删除失败");}}else {boolean flagn=true;try {File dir = file2.getParentFile();dir.mkdirs();flagn = file2.createNewFile();System.out.println("创建成功");}catch (IOException e){System.out.println("创建失败");e.printStackTrace();}}}
}

枚举类

所有的枚举类型隐性地继承Java.lang.Enum.枚举实质上还是类，而每个被枚举的成员实质就是一个枚举类型的实例，默认都是public static final 修饰的，可以直接通过枚举类型名使用。

注意

当需要定义一组常量，可以使用枚举类型
尽量不要使用枚举的高级特性，事实上高级特性都可以使用普通类来实现，没有必要引入枚举，增加程序的复杂性。

ublic class test {public static void main(String[] args)  {System.out.println(Season.SPRING);Season a = Season.AUTUMN;switch (a){case SPRING:System.out.println("春天");break;case SUMMER:System.out.println("夏天");break;case AUTUMN:System.out.println("秋天");break;case WINTER:System.out.println("冬天");break;}}
}
enum Season{SPRING,SUMMER,AUTUMN,WINTER
}
enum Week{星期一,星期二,星期三,星期四,星期五,星期六,星期日,
}

Java基础（2）面向对象的理解相关推荐

再探java基础——对面向对象的理解(1)
对象对象是人们要进行研究的任何事物,从最简单的整数到复杂的飞机等均可看作对象,它不仅能表示具体的事物,还能表示抽象的规则.计划或事件.对象具有属性和行为,在程序设计中对象实现了数据和操作的结合,使数 ...
一文带你深入理解【Java基础】· 面向对象编程（下）②代码块、final和abstract
写在前面 Hello大家好, 我是[麟-小白],一位软件工程专业的学生,喜好计算机知识.希望大家能够一起学习进步呀!本人是一名在读大学生,专业水平有限,如发现错误或不足之处,请多多指正!谢谢大家!!! ...
Java基础篇--面向对象(Object Oriented)
Java基础篇--面向对象(Object Oriented) 1. 面向对象概念 1.1 什么事面向对象 1.2 理解面向对象 1.3 面向对象的特点 1.4 面向对象开发设计特征 2. 类与对象 2 ...
Java基础-初识面向对象编程（Object-Oriented-Programming）
Java基础-初识面向对象编程(Object-Oriented-Programming) 作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. Java是一门面向对象的程序设计语言.那么什 ...
Java基础之面向对象的概念继承---组合----枚举类
Java基础之面向对象的概念继承---组合----枚举类本章作为面向对象概念的最后一篇,但是作为一名java程序员在面向对象的这条路上还很长. 一.继承与组合简介继承是实现类重用的重要手段,但是 ...
【Java基础】面向对象（三）
[Java基础]面向对象(三) 一.多态概念引用类型转换二.Object类概述常用方法三.抽象类抽象类与抽象方法的定义注意事项四.接口概述接口定义含有抽象方法含有默认方法和静 ...
JAVA基础学习--面向对象
JAVA基础学习–面向对象 1.面向对象与面向过程: 面向过程:就代表从头到位,每一步都需要我们来完成,例如洗衣服,首先收拾脏衣服.接上水.到洗衣液.搓.倒水.拧干.晾晒.每一步都需要我们来完成. 面 ...
java基础(一)-面向对象思想
前言 java是一门面向对象的语言,在学习java前,先要理解面向对象这个概念,区别于c这类的面向过程语言,面向对象有着什么一样的特点呢?先上一张思维导图吧: 对象什么是对象问题空间中的元素及其在 ...
Java基础(08) 面向对象
Java基础(八)-- 面向对象面向对象(Object Oriented Programming, 简称OOP )是Java基础学习的重点,必须掌握每个细节,接下来对面向对象的学习主要围绕以下三 ...
JAVA基础语法——面向对象思想
Java基础语法前言一.面向对象思想 1.面向对象(OOP)概述 2.面向对象三大特性五大原则二.类和对象 1.对象和类的概念 2.对象的特征 3.构造方法 3.This关键字 4.static ...

Java基础（2）面向对象的理解

面向对象学习

面向对象与面向过程的区别

对象是什么，对象和数据管理

对象和类的关系、属性、成员变量、方法

对象和类的概念

一个典型类的定义和类的UML图

内存分析

栈

堆

方法区

构造方法

垃圾回收机制

垃圾回收相关算法

通用的分代垃圾回收机制

this关键字

对象创建的过程

this的本质

static关键字

静态初始化块（讲完继承回头再看一遍）

参数传值机制

Java包机制

import详解

面向对象三大特征

继承

方法的重写override

object类的用法

super关键字

封装的作用和含义

封装的优点：

封装的实现—使用访问控制符

封装的使用细节

多态

多态的要点

对象的转型

final关键字

数组

数组的初始化

数组的遍历

数组的拷贝

数组的扩容

Arrays类

多维数组

数组存储表格数据

冒泡排序优化排序

基本算法

优化算法

二分法查找（折半检索）

抽象类、抽象方法

抽象方法

抽象类

使用要点

接口

要点

内部类

成员内部类

非静态内部类

成员变量访问要点

静态内部类

使用要点

匿名内部类

局部内部类

string类

StringBuilder(可变字符串序列)

注意

常量池

包装类

自动装箱和拆箱

DATE 时间类

DataFormat 类和 SimpleFormat 类

Calendar和GregorianCalendar的使用

File类

枚举类

注意

Java基础（2）面向对象的理解相关推荐

最新文章

热门文章