目录
1.1 面向对象与面向过程
面向过程：强调功能行为，以函数为最小单位，考虑怎么做。
面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁做。
一、面向对象三条主线：
1、Java类及类的成员：属性、方法、构造器；代码块、内部类
2、面向对象的三大特征：封装性、继承性、多态性、（抽象性）
3、其他关键字：this、super、static、final、abstract、interface、package、import
1.2 Java基本元素：类和对象
一、面向对象两个要素：
1、类：对一类事物的描述，是抽象的、概念上的定义。（eg.动物）
2、对象：是实际存在的该类事物的每个个体，也成为实例（instance）（eg.兔子）
二者关系eg.
与控制台交互时，需要提供一个类，API已提供了一个Scanner类，执行时要创建一个Scanner的对象，通过对象去调用方法，去完成与控制台的交互。
对象是由类派生出来的。
二、理解“万事万物皆对象”
1、在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。
>Scanner，String等
>文件：File
>网络资源：URL
2、涉及到Java语言与前端Html、后端数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
三、设计类：本质为设计类的成员
属性 = 成员变量 = field = 域、字段
String name; //String默认值为null
int age; //int默认值为0
boolean isMale; //boolean默认值为 false
//调用属性：‘‘对象.属性’’ p1.name=''Tom'';方法 = 成员方法 = 函数（C语言）= method
public void talk(String language){
System.out.println("人能说话，用的是："+ language);
} //调用方法：‘‘对象.方法’’ p1.talk("Chinese"); 创建类的对象 = 类的实例化 = 实例化类
Person p1 = new Person();//Scanner scanner = new Scanner(System.in);
//调用对象的结构：属性、方法
四、类和对象的使用
1、创建类，设计类的成员
2、创建类的对象
3、通过‘‘对象.属性’’ 或‘‘对象.方法’’调用对象的结构
五、匿名对象的使用
1、理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象。
2、特征：匿名对象只能调用一次。
3、使用：如下
public class InstanceTest {
public static void main(String[] args) {
new Phone().price=1999;
new Phone().showPrice();//0.0
//************************
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());//匿名
}
}
class PhoneMall{
public void show (Phone phone) {//上面的new Phone()赋给phone，此时可以用多次，赋给phone时算有名
phone.sendEmail();
phone.playGames();//调用的是同一个对象
}
}
class Phone{
double price;
public void showPrice() {
System.out.println("显示价格: " + price );
}
public void sendEmail() {
System.out.println("发送邮件");
}
public void playGames() {
System.out.println("玩游戏");
}
}1.3 对象的创建和使用
创建一个类的多个对象，每个对象独立的拥有一套类的属性（非static），意为修改一个对象的属性a，不影响另外一个对象的属性a的值。
一、对象的内存解析
1、堆（Heap） ，存放对象实例，几乎所有的对象实例都在这里分配内存，在Java虚拟机规范中描述的是：所有的对象实例以及数组都要在堆上分配。
2、栈（Stack），指虚拟机栈。虚拟机栈用于存储局部变量。存放基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，不等同于对象本身，是对象在堆中存首地址）。方法执行完自动释放（垃圾回收机制）。
3、方法区（Method Area）：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
二、内存解析说明
1、引用类型的变量，只可能存储两类值：null或地址值（含变量的类型）。
内存解析例①
Person p1 = new Person();
p1.name="Tom";
p1.isMale = ture;
Person p2 = new Person();
System.out.println(p2.name);
Person p3 = p1;
p3.age=10; 
三、JVM内存结构
编译完源程序以后，生成一个或多个字节码文件.class。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
1.4 类的成员：属性
一、类中属性的使用
属性（成员变量）VS 局部变量
1、相同点：
①定义变量的格式：数据类型 变量名 = 变量值
②先声明，后使用
③变量都有其对应的作用域
2、不同点：
①在类中的声明位置不同
属性：直接定义在类的{}中
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
②关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected （封装性）
局部变量：不可以使用权限修饰符。
3、默认初始化值：
属性：类的属性，根据其类型，都有默认初始化值。
| 整型(byte、short、int、long) | 默认值：0 |
| 浮点型(float、double) | 默认值：0.0 |
| 字符型(char) | 默认值：0(或'\u0000') |
| 布尔型(boolean) | 默认值：false |
| 引用数据类型(类、数组、接口、String) | 默认值：null |
局部变量：没有默认初始化值。
所以，在调用局部变量之前要显式赋值。
特别情况：形参在调用时赋值即可。
public void eat(){
String food = '烙饼';//赋值不能去掉，否则报错（显性赋值）
System.out.println("人们喜欢吃：" + food);
} public void talk(String language){
System.out.println("使用" + language + "进行语言交流");
}// User u1 = new User(); 用u1.talk("日语"); 赋值 (形参在调用时赋值)4、在内存中加载的位置：
属性：加载到堆空间中（非static，static的属性加载到方法区）
局部变量：加载到栈空间
1.5 类的成员：方法
一、类中方法的声明和使用
方法：描述类应该具有的功能。
例如：Math类：sqrt() \ random() \ ...
Scanner类：nextXxx() ...
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
1、举例：①有/无形参 ②有/无返回值
2、方法的声明：权限修饰符 返回值类型 方法名(形参列表){
方法体
}
3、说明
①关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected
②返回值类型：有返回值 VS 无返回值
若有返回值，则必须在方法声明时指定返回值类型。同时方法中需要使用return
关键字来返回指定类型的变量或常量。“return 数据;”
若无返回值，则方法声明时使用void表示。通常不用return，但是若使用则只能
用“return;” 表示结束此方法的意思。
③方法体：方法功能的体现。
④return关键字的使用：
使用范围：使用在方法体中
作用：结束方法、返回数据
注意点：return后不可以声明执行语句。
⑤方法的使用中，可以调用当前类的属性或方法。（方法A中又调用方法A为递归方法）
4、例题
例①：栈溢出分析
public void sleep(int hour){
System.out.println("休息了" + hour + "个小时");
sleep(10);
}//调用时栈溢出
调用sleep方法时，局部变量（形参）放入栈中，在sleep方法里又调用了sleep方法，再次把局部变量放入栈中，循环直到栈溢出。（StackOverflowError）
例②：内存解析
public class Person{
String name;
int age;
int sex;
public int addAge(int i){
age += i;
return age;
}
}
public class PersonTest{
public static void main(String[] args){
Person p1 = new Person();
p1.name = "Tom";
p1.age = 18;
p1.sex = 1;
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄为：" + newAge);
System.out.println(p1.age);//20
}
}
要点：把2赋给i，由此p1.age=20（为什么是p1.age?是因为一开始调用的是p1的方法addAge()，所以修改p1.age），并把20赋给newAge。当addAge()方法结束，i的生存周期结束并出栈销毁。
p1出栈时，指针消失，指针所指的对象属性也被堆空间垃圾回收。
例③：利用面向对象编程方法，设计类Circle计算圆的面积。
public class CircleTest {
public static void main(String[] args) {
Circle r=new Circle();
r.radius=2.1;
double area=r.findarea();
System.out.println(area);
}
}
class Circle{
double radius;
public double findarea() {//不可带形参，如：r，因为已有属性radius
double area=Math.PI * radius* radius;
return area;
}
}
例④：对象数组内存解析
public class StudentTest {
public static void main(String[] args) {
Student[] s=new Student[5];
s[0]=new Student();
System.out.println(s[0].state);//1
System.out.println(s[1]);//null
System.out.println(s[1].state);//异常
}
}
class Student{
int number;
int state = 1;
int score;
}
1.6 再谈方法
一、方法的重载
1、定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
2、判断是否重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。
3、在通过对象调用方法时，如何确定某一个指定的方法：方法名——>参数列表
二、可变个数形参方法
1、jdk 5.0 新增的内容
2、具体使用：（sql，？，条件个数不确定）
① 可变个数形参的格式：数据类型 ... 变量名
②当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、2个......
③可变个数形参方法与本类中方法名相同，形参不同的方法之间构成重载
④可变个数形参方法与本类中方法名相同，形参类型也相同的数组之间不构成重载
⑤可变个数形参在方法的形参中，必须声明在末尾
⑥可变个数形参在方法的形参中，最多只能声明一个可变形参
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test=new MethodArgsTest();
test.show("111","word");//可变个数的形参
test.show(new String[] {"aa","bb","cc"});//建立数组
}
public void show(String ...strings) {
for(int i=0;i<strings.length;i++) {
System.out.println(strings[i]);//数组遍历
}
}
public void show(int i,String...strings) {//可变声明在后
}
}三、方法参数的值传递机制
1、关于变量的赋值：
①如果变量是基本数据类型，此时赋值的是变量所保存的数据值
②如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
2、方法的形参传递机制：值传递
①形参：方法定义时，声明的小括号的参数
②实参：方法调用时，实际传递给形参的数据
3、值传递机制：
①如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值
main(){
int m=10;
int n=20;
对象.swap(m,n);//调用swap方法
System.out.println(m,n);//输出的是主函数里的m,n
//swap函数中的m和n已经在swap方法结束后出栈销毁
//所以m,n的输出依然为10,20
}
swap(int m,int n){
int temp=m;
m=n;
n=temp;
System.out.println(m,n);
}
②如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值
class Data{
int m;
int n;
}
main(){
Data data=new Data();
data.m=10;
data.n=20;
对象.swap(data);
System.out.println(data.m,data.n);
}
swap(Data data){
int temp=data.m;
data.m=data.n;
data.n=temp;
}
4、递归方法：
①一个方法体内调用它自身
②方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须控制循环。递归一定要向一直方向递归，否则这种递归就变成了无穷递归，类似于死循环。
5、例题
例①：方法参数的传递
public class TransferTest3 {
public static void main(String[] args) {
TransferTest3 test =new TransferTest3();
test.first();
}
public void first() {
int i=5;
Value v=new Value();
v.i=25
second(v,i);//执行完second后v,i,val依次出栈,同时指针消失,
//堆空间的v与val所指向的属性i也被当做垃圾回收
System.out.println(v.i);//20
}
public void second(Value v,int i) {
i=0;
v.i=20;
Value val=new Value();
v=val;
System.out.println(v.i+" "+i);//15 0
}
}
class Value{
int i=15;
}
例②：
public class Test{
public static void main(String[] args) {
int a=10;
int b=20;
method(a,b);//需要在method方法被调用后,
//仅打印出a=100,b=200,请写出method的代码
System.out.println("a="+a);
System.out.println("b="+b);
}
public static void method(int a,int b) {//方法一
a=a*10;
b=b*10;
System.out.println("a="+a);
System.out.println("b="+b);
System.exit(0);
}
public static void method(int a,int b) {//方法二
PrintStream ps=new PrintStream(System.out) {
@Override
public void println(String x) {
if("a=10".equals(x)) {
x="a=100";
}
else if("b=20".equals(x)){
x="b=200";
}
super.println(x);
}
};
System.setOut(ps);
}
}例③：问arr与arr1的输出？
int[] arr=new int[10];
System.out.println(arr);//arr输出地址值
char[] arr1=new char[]{'a','b','c'};
System.out.println(arr1);//arr1输出abc
例④：定义一个PassObject, 在类中定义一个方法printAreas()，
该方法的定义如下：public void printAreas(Circ1e c,int time)在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如：time为5， 则输出丰径1,2,3,4,5 以及对应的圆面积。在main方法中调用printAreas()方法，调用完毕后输出当前半径值。
public class PassObject {
public static void main(String[] args) {
PassObject test=new PassObject();
Circle1 c=new Circle1();
test.printAreas(c, 5);
}
public void printAreas(Circle1 c,int time) {
for(int i=1;i<=time;i++) {
c.radius=i;
double area=c.findArea();
System.out.println(c.radius+"\t\t"+c.findArea());
}
}
}
public class Circle1 {
double radius;
public double findArea(){
return Math.PI*radius*radius;
}
}例⑤：递归
public class RecursionTest {
public static void main(String[] args) {
//计算1--输入数字之间所有自然数的和
RecursionTest test=new RecursionTest();
int sum1=test.getSum(16039);
System.out.print(sum1);
}
public int getSum(int n) {//从后往前
if(n==1) {
return 1;
}else {
return n+getSum(n-1);
}
}
}例⑥：递归2
已知有一个数列，f(0)=1，f(1)=4，f(n+2)=2*f(n+1)+f(n)，n是大于0的整数，求f(10)。
public class RecursionTest {
public static void main(String[] args) {
RecursionTest test=new RecursionTest();
int jieguo=test.f(10);
System.out.print(jieguo);
}
public int f(int n) {
if(n==0) {
return 1;
}else if(n==1) {
return 4;
}else {
return 2*f(n-1)+f(n-2);//把f(n+2)看成f(n),防止不断调用f函数,栈溢出
}
}
}例⑦：递归3
计算斐波那契数列第n个值，并将整个数列打印出来
public class RecursionTest {
public static void main(String[] args) {
RecursionTest test=new RecursionTest();
int jieguo=test.g(10);//斐波那契数列
System.out.println("数字为："+jieguo);
for(int n=1;n<=10;n++) {
jieguo=test.g(n);
System.out.print(jieguo+"\t");
}
}
public int g(int n) {
if(n==1) {
return 1;
}else if(n==2) {
return 1;
}else {
return g(n-1)+g(n-2);
}
}
}
1.7 面向对象的特征：封装与隐藏
一、问题引入
当创建一个类的对象以后，可以通过‘对象.属性’’的方式，对对象的属性进行赋值。赋值操作会受到属性的数据类型和存储范围的制约。实际问题中，会给属性赋值加入额外的限制条件，而且只能通过方法进行限制条件的添加。eg：避免出现a.legs(负数)，在方法中加限制条件。若想避免再使用‘对象.属性’’的方式对属性赋值，则需要将属性声明为私有的（private）
此时，针对于属性就体现了封装性。
二、封装性的体现
将类的属性xxx私有化（private），同时提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值。
拓展：封装性的体现还有①不对外暴露私有的方法②单例模式...
三、修饰符
1、Java规定的4种权限（从小到大排列）：private、缺省、protected、public
| 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
|---|---|---|---|---|
| private | Yes | |||
| 缺省 | Yes | Yes | ||
| protected | Yes | Yes | Yes | |
| public | Yes | Yes | Yes | Yes |
2、4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3、修饰类只能使用：缺省、public
四、总结
封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
1.8 类的成员：构造器（或构造方法）
一、构造器的作用：
1、创建对象
2、初始化对象的信息
二、说明
1、如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
public class PersonTest{
public static void main(String[] args){
//创建类的对象：new+构造器
Person p=new Person();
}
}
class Person{
public Person(){//空参构造器
}
}2、定义构造器的格式：权限修饰符 类名(形参列表){}
3、一个类中定义的多个构造器，彼此构成重载
4、一旦显式定义了类的构造器之后，系统就不再提供默认的空参构造器
5、一个类中，至少会有一个构造器
三、拓展
1、属性赋值的先后顺序
①默认初始化——>②显式初始化——>③构造器中赋值——>④“对象.方法”或“对象.属性”赋值
2、JavaBean是一种Java语言写成的可重组组件
①类是公共的
②有一个无参的公共构造器
③有属性，且有对应的get、set方法
1.9 关键字：this的使用
一、使用
1、this可以用来修饰：属性、方法、构造器
2、this修饰属性和方法时，this理解为：当前对象 或 当前正在创建的对象
在类的方法/构造器中，可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法/当前正在创建的对象属性或方法通常情况下会选择省略“this.”特殊情况下，如果方法/构造器的形参和类的属性同名时，必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。
3、this调用构造器
①在类的构造器中，可以显式使用“this（形参列表）”方式，调用本类中指定的其他构造器
②构造器不能通过“this（形参列表）”方式调用自己
③如果一个类中有n个构造器，则最多有n-1构造器中使用了“this（形参列表）”
④规定：“this（形参列表）”必须声明在当前构造器的首行
⑤构造器内部，最多只能声明一个“this（形参列表）”用来调用其他的构造器
1.10 package、import的使用
一、package的关键字的使用
1、为了更好的实现项目中的类的管理，提供包的概念
2、使用package声明类或接口所属的包，声明在源文件的首行
3、包，属于标识符，遵守标识符的命名规则“见名知意”
4、每“.”一次就代表一层文件目录
二、import关键字的使用
1、在源文件中显式的使用import结构导入指定包下的类、接口
2、声明在包的声明和类的声明之间
3、如果需要导入多个结构，则并列写出
4、可以使用“xxx.*”的方式，表示可以导入xxx包下的所有结构
5、如果使用的类或接口是java.lang包下定义的，可以省略import结构
6、如果使用的类或接口是本包下定义的，可以省略import结构
7、如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
8、import static：导入指定类或接口中的静态结构：属性或方法
9、使用”xxx.*“方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则要显式导入
1859
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
