面向对象（上）
1.类与对象
类是对某一类事物的抽象描述
对象用于表示现实中该类事物中个体
一.类的定义
[修饰符] class 类名 {
类体 = 属性 + 方法
//类体=属性+方法
属性在代码上以"变量"的形式存在(描述状态)
方法描述动作/行为
}
举例
public class XueSheng {
int number; //学号
String name; //姓名
boolean sex; //性别
int age; //年龄
}
number、name、age、sex 都是实例变量/属性，这些变量在 new对象的时候初始化，如果没有手动赋值，系统会赋默认值。
二.变量的分类
变量根据出现位置进行划分:
方法体当中声明的变量:局部变量
方法体外声明的变量:成员变量。(这里的成员变量就是属性）
三.对象的创建与使用
创建对象的语法格式
类名 对象名称 = new 类名()
XueSheng s1=new XueSheng();
对象的引用访问对象所有的成员
java中所有类都属于引用数据类型,我们可以用String类型来类比该写法,创建对象后可以通过对象的引用访问对象所有的成员
对象引用.对象成员
s1.name="XXX";
举例
public class XueShengTest {
public static void main(String[] args){
XueSheng s1=new XueSheng();
s1.name="XXX";
}
}
Student s1 = new Student()实际上和 int i = 10 是类似的，对于 int i = 10 来说，int 是一种基本数型，i 是变量名，10 是 int 类型的字面量。那对于 Student s1 = new Student()来说，其中 Student 是一种引用数据类型，s1 是变量名，new Student()执行之后是一个 Student 类型的对象。
XueSheng s1=new XueSheng();来说，其中 XueSheng 是一种引用数据类型，s1 是变量名，new XueSheng()执行之后是一个 Student 类型的对象。且不能通过类名直接访问实例变量XueSheng.name is wrong
创建XueSheng 对象后，可以通过对象的引用访问对象所有的成员
同时可以通过“=”赋值的方式将内存中实例变量的值进行修改
public class XueShengTest {
public static void main(String[] args){
XueSheng s1=new XueSheng();
System.out.println(s1.name);
System.out.println(s1.number);
System.out.println(s1.addr);
System.out.println(s1.sex);
System.out.println(s1.age);
System.out.println("-----------------------------------------");
XueSheng s2=new XueSheng();
s2.name="lupeng";
s2.age=20;
s2.number=1902;
s2.addr="Wuhan";
s2.sex=true;
System.out.println(s2.name);
System.out.println(s2.number);
System.out.println(s2.addr);
System.out.println(s2.sex);
System.out.println(s2.age);
}
}
null
0
null
false
0
lupeng
1902
Wuhan
true
20
内存图分析
四.引用和对象的区分
引用是存储对象内存地址的一个变量 XueSheng s1=new XueSheng();中s1
对象是堆里new出来的 new XueSheng();
引用不一定是局部变量还可能是成员变量基础p233
五.方法调用的参数传递
（1）基本数据类型传递
public class Test1 {
public static void main(String[] args) {
int i=10;
System.out.println(i);
add(i);
}
public static int add(int x){
++x
System.out.println(x);
return x;
}
}
10
11
（2）引用数据类型传递
public class Test1{
public static void main(String[] args){
Person p=new Person();
p.age=10;
add(p);
System.out.println("main--->"+p.age);
}
public static void add(Person p){
p.age++;
System.out.println("add--->"+p.age);
}
}
class Person{
int age;
}
add—>11
main—>11
1.不管你是基本数据类型,还是引用数据类型
2.实际在传递的时候都是将变量中保存的那个值
3.将变量中保持的那个“值”复制一份,传过去
六.空指针异常
个人觉得比较简单，暂不举例，就是对象的引用为null，编译器编译不报错，运行报错
2.方法的重载和递归
3.构造方法
1.定义
构造方法是类中特殊的方法，通过调用构造方法来完成对象的创建，以及对象属性的初始
化操作。
语法
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
}
修饰符列表统一写public ，不要写public static
① 构造方法名和类名一致。
② 构造方法用来创建对象，以及完成属性初始化操作。
③ 构造方法返回值类型不需要写，写上就报错，包括 void 也不能写。
④ 构造方法的返回值类型实际上是当前类的类型。
⑤ 一个类中可以定义多个构造方法，这些构造方法构成方法重载。
2.构造方法的调用
用new运算符调用构造方法
new 构造方法名(实际参数列表)
new Student();
举例
Student类
public class Student {
int no;
int age;
String name;
public Student(){
System.out.println("无参数构造方法执行");
}
public Student(int age){
this.age=age;
System.out.println("有参构造方法执行");
}
}
ConstructorTest01 类
public class ConstructorTest01 {
public static void main(String[] args) {
//
ConstructorTest01.dosome();
dosome();
Student s1=new Student();
Student s2=new Student(20);
System.out.println(s2.age);
}
public static void dosome(){
System.out.println("do some");
}
}
do some
do some
无参数构造方法执行
有参构造方法执行
20
注意
1、当一个类中没有提供任何构造方法,系统默认提供一个无参薮的构造方法
这个无参薮的构造方法叫做缺省构造器
2、当一个类中手动的提供了构造方法,那么系统将不再提供无参数构造方法所以建议将无参构造方法写出不容易出问题
3、无参数构造方法,和有参数的构造方法都可以调用
Student x new student();
Student y new student(123)；
4、构造方法支持方法重载吗?
构造方法是支持方法重载的
在一个类当中构造方法可以有多个并且所有的构造方法名字都是一样的
这里重复方法重载同一个类中，参数列表不同算方法重载
5.实例变量不是在类加载时完成初始化，而是在构造方法执行的过程中完成初始化的
4.类的封装
使用 java 语言中的 private 修饰符，private 修饰的数据表示私有的，私有的数据只能在本类当中访问通常情况下我们访问对象的某个属性，不外乎读取（get）和修改（set），所以对外提供的访问入口应该有两个，这两个方法通常被称为 set 方法和 get 方法set 和 get 方法访问的都是某个具体对象的属性，不同的对象调用 get 方法获取的属性值不同，所以 set 和 get 方法必须有对象的存在才能调用，这样的方法定义的时候不能使用 static 关键字修饰，被称为实例方法。
一.封装的代码实现两步：
第一步：属性私有化
private int age;
第二步：1个属性对外提供两个set和get方法。
外部程序只能通过set方法修改只能通过get方法读取
可以在set方法中设立关卡来保证数据的安全性。
public int getAge(){
return age;
}
public void setAge(int lianLing){
if(lianLing<0||lianLing>=150){
System.out.println("buhefa");
return;
}
age=lianLing;
}
5.this关键字
一.this概述
1、this是一个关键字,全部小写
2、this是什么,在内存方面是怎样的?
一个对象一个this,this是一个变量,是一个引用。this保存当前对象的内存地址,指向自身,所以,严格意义上来说,this代表的就是当前对象
3.this存储在堆内存当中对象的内部。(从内存图中看出)
4.为什么this不能使用在静态方法中?
this代表当前对象,静态方法中不存在当前对象,所以this只出现实例方法而不是静态方法
二.举例
public class ThisTest01{
public static void main(String[] args){
Customer c1=new Customer("zhansan");
Customer c2=new Customer("lisi");
}
}
class Customer{
String name;
public Customer(){
}
public Customer(String s){
name=s;
}
}
三.this关键字不能省略
在实例方法中,或者构造方法中,为了区分局部变量和实例变量,这种情况下:this.是不能省略的
public class ThisTest03{
public static void main(String[] args){
Student2 s=new Student2();
s.setNo(11211);
s.setName("zhansann");
System.out.println(s.getNo());
System.out.println(s.getName());
Student2 s2= new Student2(235,"lupeng");
System.out.println(s2.getNo());
System.out.println(s2.getName());
}
}
class Student2{
private int no;
private String name;
public Student2(){
}
public Student2(int no,String name){
this.no=no;
this.name=name;
}
public void setNo(int no){
this.no=no;
}
public int getNo(){
return no;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
}
11211
zhansann
235
lupeng
四.this用于构造方法
1、this除了可以使用在实例方法中,还可以用在构造方法中
2、新语法:通过当前的构造方法去调用另一个本类的构造方法,可以使用以下语法格式:
this(实际参数列表)
通过一个构造方法1去调用构造方法2,可以做到代码复用
但需要注意的是:N构造方法1和w构造方法2〃都是在同一个类当中
3、this()这个语法作用是什么?
代码复用
4.在构造方法中，使用this调用构造方法的语句必须是该方法的第一条执行语句,且只能出现一次
public class Thistest04{
public static void main(String[] args){
Date d1=new Date();
d1.detail();
Date d2=new Date(2000,8,8);
d2.detail();
}
}
class Date{
private int year;
private int month;
private int day;
public Date(){
/*this.year=1970;
this.month=1;
this.day=1;*/
//this(1970,1,1);
}
public Date(int year,int month,int day){
this.year=year;
this.month=month;
this.day=day;
}
public void detail(){
System.out.println(year+"年"+month+"月"+day+"日");
}
public void setYear(int year){
this.year=year;
}
public int getYear(){
return year;
}
public void setMonth(int month){
this.month=month;
}
public int getMonth(){
return month;
}
public void setDay(){
this.day=day;
}
public int getDday(){
return day;
}
}
1970年1月1日
2000年8月8日
6.static关键字
概述
static 是 java 语言中的关键字，表示“静态的”，它可以用来修饰变量、方法、代码块等，修饰的变量叫做静态变量，修饰的方法叫做静态方法，修饰的代码块叫做静态代码块。在 java语言中凡是用 static 修饰的都是类相关的，不需要创建对象，直接通过“类名”即可访问，即使使用“引用”去访问，在运行的时候也和堆内存当中的对象无关。
static
1.static翻译为“静态”;修饰静态变量和方法
2.所有staic修饰的，都是采用“类名.”的方式访问
变量的分类
变量根据声明的位置进行划分
在方法体当中声明的变量叫做：局部变量
在方法体外声明的变量叫做：成员变量
成员变量又可以分为
实例变量
静态变量
class VarTest {
//实例变量
int i;
//静态变量
static int k;
//静态方法
public static void m1() {
}
//实例方法
public void m2() {
}
}
一.静态变量
在类体中定义的变量为成员变量，而成员变量又包括实例变量和静态变量，当成员变量声明时使用了 static 关键字，那么这种变量称为静态变量，没有使用 static 关键字称为实例变量，实例变量是对象级别的，每个对象的实例变量值可能不同，所以实例变量必须先创建对象，通过“引用”去访问，而静态变量访问时不需要创建对象，直接通过“类名”访问。
注意
静态变量在类加载时初始化,不需要new对象,静态变量的空间就开出来了静态变量存储在方法区
Chinese类
class Chinese{
String name;
int id;
static String country="Chinese";//静态变量
public void Chinese(){
}
public Chinese(String name,int id){
this.id=id;
this.name=name;
}
}
测试类
public class StaticTest02 {
public static void main(String[] args){
Chinese c1=new Chinese("lupeng",1902);
Chinese c2=new Chinese("ying",1906);
System.out.println(c1.id);
System.out.println(c1.country);
System.out.println(c1.name);
System.out.println(c2.id);
System.out.println(c2.country);
System.out.println(Chinese.country);
System.out.println(c2.name);
}
}
1902
Chinese
lupeng
1906
Chinese
Chinese
ying
这里可以用类名也可以用引用访问,其实还是转换为Chinese.country
内存图
从内存图我们知道方法都是压栈的，也可知静态变量在类加载时初始化同时存储在方法区
注意
1.只要是方法，不管是静态方法、实例方法、构造方法,它们在运行的时候都是需要压栈。
2.如果这个类型的所有对象的某个属性值都是一样的,不建议定义为实例变量,浪费内存空间。建议定义为类级别特征,定义为静态变量,在方法区中只保留一份,节省内存开销
二.静态方法与实例(非静态)方法
有static 静态方法
无static 实例方法
public class StaticTest04{
public static void main(String[] args){
StaticTest04.dosome();
StaticTest04 st=new StaticTest04();
st.dosome();
st=null;
st.dosome();
//st.doOther();
StaticTest04 st2=new StaticTest04();
st2.doOther();
}
//静态方法(静态方法不需要new对象,直接使用“类名.”来访问)
//但是也可以使用“引用.”来访问，不建议使用
public static void dosome(){
System.out.println("静态方法dosome()执行了");
}
//实例方法(实例相关的都需要new对象,使用“引用.”来访问
public void doOther(){
System.out.println("实例方法");
}
}
静态方法dosome()执行了
静态方法dosome()执行了
静态方法dosome()执行了
实例方法
总结
静态代码块
一.语法格式
类{
//静态代码块
static{
java 语句;
}
}
二.执行特点
静态代码块在类加载时执行，并且只执行一次。 静态代码块实际上是 java 语言为程序员准备的一个特殊的时刻，这个时刻就是类加载时刻.同时静态变量也在类加载时候执行，时间相同，只能靠代码执行顺序来决定先后
三.举例
public class StaticTest07{
//静态变量在类加载时初始化
//静态变量存储在方法区
static int i=100;
//静态代码块在类加载时执行
static{
System.out.println("i="+i);
}
int k=13432;
//实例变量在构造方法执行时在堆区存储
static String name="zhangsan";
static{
/* System.out.println("k="+k);
java: 无法从静态上下文中引用非静态 变量 k*/
System.out.println("name"+name);
}
public static void main(String[] args){
System.out.println("main begin");
}
}
i=100
namezhangsan
main begin
各种变量区分
各种方法的调用
程序再怎么变化,万变不离其宗,有一个固定的规律:
所有的实例相关的都是先创建对象,通过引用.来访问
所有的静态相关的都是直接来用"类名."来访问
总有一些是需要记忆的,在这些记忆的基础之上进行分析
大结论:
只要负责调用的方法a和被调用的方法b在同一个类当中:
this.可以省略
类名.可以省略
public class Review {
int i=100;
static int j=2000;
public void m1(){
//访问其他类的静态方法
T.t1();
//访问其他类的实例方法
T t=new T();
t.t2();
}
public void m2(){
}
public void x(){
m1();
m2();
m3();
System.out.println(i); // System.out.println(this.i);
System.out.println(j); // System.out.println(Review.j);
}
public static void m3(){
}
public static void m4(){
}
public static void main(String[] args) {
m3();
// System.out.println(i); 报错
System.out.println(j);
Review r=new Review();
r.m1();
r.m2();
int k=1000;
System.out.println(k);
}
}
class T{
public static void t1(){
}
public void t2(){
}
}
2000
1000
实例语句块
1.语法
{
}
实例语句在类加载时并没有执行，但在构造方法执行之前执行
2.举例
public class InstanceCode{
public static void main(String[] args){
System.out.println("main begin");
new InstanceCode();
new InstanceCode();
new InstanceCode("avsvs");
}
//实例语句块
{
System.out.println("实例语句块执行");
}
public InstanceCode(){
System.out.println("无参数");
}
public InstanceCode(String name){
System.out.println("有参数的构造方法");
}
}
main begin
实例语句块执行
无参数
实例语句块执行
无参数
实例语句块执行
有参数的构造方法