面对对象
面向过程 强调的是功能行为
面向对象 将功能封装进对象，强调具备了功能的对象
面向对象是基于面向过程的。
特点： 是一种符合人们思考习惯的思想 可以将复杂的事情简单化 将程序员从执行者转换成指挥者
完成需求时：先要去找具有所需的功能的对象来用，如果该对象不存在 那么就创建一个具有所需功能的对象 这样简化开发并提高复用
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情
设计的过程：其实就是在管理和维护对象之间的关系
面向对象的特征：封装 继承 多态
类与对象
类：对现实生活中的事物的描述
对象：这类事物，实实在在存在的个体
描述就是class定义的类
具体对象就是java在堆内存中用new建立实体
属性：对应类中的成员变量
行为：对应类中的成员函数
class Car
{
//属性 颜色、轮胎数
String color = "红色";
int num = 4;
//行为 运行行为
void run()
{
System.out.println(color + "..." +num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//通过new操作符 在堆内存中产生实体 类类型变量指向对象
//产生了对象 数据类型 对象名 = new 类
Car c = new Car();
c.run();
}
}
成员变量和局部变量
成员变量
成员变量定义在类中，在整个类中都可以被访问。
成员变量随着对象的建立而建立，存在于对象所在的堆内存中
成员变量有默认初始化值
局部变量
局部变量只定义在局部范围内，如：函数中，语句内等。
局部变量存在于栈内存中
作用的范围结束，变量空间会自动释放
局部变量没有默认初始化值
匿名对象
匿名对象是对象的简化形式
情况：1、当对对象方法仅进行一次调用的时候；2、匿名对象可以作为实际参数进行传递
//需求 对汽车进行改装 将来的车改为黑色、三个轮胎
class Car
{
//定义汽车轮胎数 、颜色
int num;
String color;
void run()
{
System.out.println(color + "..." + num);
}
}
class CarDemo
{
public static void main(String[] args)
{
/*
Car c1 = new Car();
show(c1);
*/
show(new Car());
}
//
public static void show(Car c)
{
c.num = 3;
c.color = "black";
c.run();
}
}
封装 Encapsulation 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
优势：将变化隔离 便于使用 提高重用性 提高安全性
原则：1、将不需要对外提供的内容都隐藏起来 2、吧属性都隐藏，提供功能方法对其访问
private 私有关键字
是一个权限修饰符 用于修饰成员(成员变量和成员函数) 被私有化的成员只在本类中有效
常用：将成员变量私有化，对外提供对应的set get方法对其进行访问，提高对数据访问的安全性
class Person
{
private int age;
//私有化 需要对外提供方法访问
public void setAge(int a)
{
if(a>=0 && a<=1300)
{
age = a;
speak();
}
else
System.out.println("error age...");
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println("age ... " + age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
p.setAge(20); //age ... 20
}
}
构造函数
特点：函数名与类名相同 不用定义返回值类型 不可以写return语句
作用：对对象进行初始化
class Person
{
//构造函数
Person()
{
System.out.println("person run....");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person(); //person run....
}
}
构造函数是在对象一建立就运行 给对象初始化 而一般方法是对象调用才运行 给对象添加对象的功能
class Person
{
private String name;
private int age;
//构造函数
Person()
{
System.out.println("A:name : " + name + "...age : " + age);
cry();
}
Person(String n)
{
name = n;
System.out.println("B:name : " + name + "...age : " + age);
cry();
}
Person(String n, int a)
{
name = n;
age = a;
System.out.println("C:name : " + name + "...age : " + age);
cry();
}
public void cry()
{
System.out.println("cry...");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p1 = new Person(); //A:name : null...age : 0 cry...
Person p2 = new Person("wu"); //B:name : wu...age : 0 cry...
Person p3 = new Person("wu",2); //C:name : wu...age : 2 cry...
}
}
注意：1、默认构造函数的特点 2、多个构造函数是以重载的形式存在的
1、有默认构造函数
2、自定义的构造函数会替代原有默认构造函数
构造代码块
{
作用：给对象进行初始化 对象一建立就运行 而且优先于构造函数执行
区别：构造代码块 是给所有对象进行统一初始化 而构造函数是给对应的对象进行初始化
}
对象
this 关键字
this代表其所在函数所属对象的引用
当在函数内需要用到调用该函数的对象时，就用this
class Person
{
private String name;
private int age;
//构造函数 局部有name 就在局部中找name this关键字使用 this.name代表对象中的name
Person(String name)
{
this.name = name;
}
public void speak()
{
System.out.println("name..." + name + "...age..." + age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person("wu");
p.speak(); //name...null...age...0
}
}
class Person
{
private int age;
Person(int age)
{
this.age = age;
}
//需求 : 比较两个人是否是同龄人
//结果 boolean
//参数 Person p
public boolean compare(Person p)
{
//定义类中功能时 该函数内部要用到调用该函数的对象时 这时用this来表示这个对象
return this.age == p.age;
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p1 = new Person(20);
Person p2 = new Person(25);
System.out.println(p1.compare(p2)); //false
}
}
构造函数之间调用
this语句只能定义在函数的第一行 构造函数之间的调用只能用this()
static(静态)关键字 方法区/共享区/数据区
1、用于修饰成员(成员变量和成员函数)
2、被修饰后的成员具备的特点：随着类的加载而加载； 优先于对象存在 被所有对象所共享；可以直接被类名调用 类名.静态成员
3、注意：静态方法只能访问静态成员 静态方法中不可以写this super关键字(静态优先于对象存在 不可存在) 主函数是静态的
main 函数 作为程序的入口被jvm调用
public 该函数的访问权限最大
static 静态 随着类的加载而已存在
void 主函数没有具体的返回值
main 函数名 被JVM识别
String[] args 函数的参数 参数类型是一个数组 该数组中的元素是字符串 字符串类型的数组
public class MainDemo
{
public static void main(String[] args)
{
String[] arr = {"aa", "bb","cc","dd"};
MainTest.main(arr); //aa bb cc dd
}
}
class MainTest
{
public static void main(String[] args)
{
for(int x=0; x<args.length; x++)
{
System.out.println(args[x]);
}
}
}
什么时候使用静态 ： 静态修饰成员变量/成员函数
什么时候定义静态变量（类变量）：当对象中的出现共享数据，该数据被静态所修饰；对象中的特有数据定义成非静态在堆内存中
什么时候定义静态函数：当功能内没有访问到非静态数据/对象的特有数据，该功能可以定义成静态。
静态的应用--工具类
帮助文档的制作--javadoc javadoc -d 目录 -author -version java文件名 public修饰
注意：一个类中会有一个默认的空参数的构造函数，其权限类型和类的权限类型一致
静态代码块 static ｛静态代码块执行语句；｝ 注意：随着类的加载而执行，只执行一次并优先于主函数。用于给类进行初始化
class staticCode
{
static
{
System.out.println("a");
}
}
class staticCodeDemo
{
static
{
System.out.println("b");
}
public static void main(String[] args)
{
System.out.println("Hello World!");
}
static
{
System.out.println("c");
}
}
/*---------- java ----------
b
c
Hello World!
*/
class staticCode
{
static
{
System.out.println("a");
}
}
class staticCodeDemo
{
static
{
System.out.println("b");
}
public static void main(String[] args)
{
new staticCode();
new staticCode();
System.out.println("d");
}
static
{
System.out.println("c");
}
}
/*---------- java ----------
b
c
a
d
*/
class staticCode
{
static
{
System.out.println("a");
}
public static void show()
{
System.out.println("e");
}
}
class staticCodeDemo
{
static
{
System.out.println("b");
}
public static void main(String[] args)
{
staticCode.show();
System.out.println("d");
}
static
{
System.out.println("c");
}
}
/*---------- java ----------
b
c
a
e
d
*/
对象初始化过程
对象调用成员过程
设计模式
单例设计模式
一个类在内存只存在一个对象