1.面向对象 要想了解面向对象,就要先了解面向过程,面向过程的代表语言是C语言,面向过程就是你想要完成一个需求,必须把完成这个需求的每一步走好,就比如你想去河对面,你就要先造船或者造桥,这就是面向过程,而面向对象时,就比如你想要过河,已经存在桥或者河了,你只需要把他们找出来供你驱使就行了,这就是面向对象. 举例,以学生为对象,学生的属性(成员变量)有:姓名,年龄,性别,学号; 行为有(成员方法):学Java,睡觉,吃饭 //定义一个学生类 class Student{ //成员变量 String name ; String gender; int age ; String id;
//成员方法 //玩游戏 public void playGame(){ System.out.println("学习无聊了，玩绝地求生游戏"); } public void sleep(){ System.out.println("学习累了,需要睡觉..."); } public void eat(){ System.out.println("学习饿了,需要吃饭..."); }} class StudentDemo{ public static void main(String[] args){ //创建学生类具体的对象 //类名 对象名 = new 类名() ; Student s = new Student(); //对象名.成员变量; //null----null-----0-----null System.out.println(s.name+"----"+s.gender+"-----"+s.age+"-----"+s.id) ;//为了方便,使用输出语句输出成员变量 //应该给当前对象s的成员赋值 s.name = “张无忌” ; s.gender = “男” ; s.age = 39 ; s.id = “9527” ; //张无忌----男-----39-----9527 System.out.println(s.name+"----"+s.gender+"-----"+s.age+"-----"+s.id) ;
}} 其中:Student s = new Student() 完成了以下几件事情: 1)将Student.class 字节码文件加载进内存 ; 2)Student s---------->进栈内存开辟空间 ; 3)new Student(); ------>在堆内存中申请空间; 4)执行Student()无参构造方法,进行系统默认初始化 5)执行显示初始化通过s.name,s.genfer …给成员变量赋值 ; 6)初始化完毕,在堆内存中产生一个空间地址值 7)将当前堆内存中,空间地址值赋值给栈内存中的变量s 2.成员变量和局部变量的区别 1)在类中的位置不同 成员变量 :类中方法外 局部变量 :方法内或者方法声明上 2)在内存中的位置不同 成员变量 :堆内存 局部变量 :栈内存 3)生命周期不同 成员变量 :随着对象的存在而存在，随着对象的消失而消失 局部变量 :随着方法的调用而存在，随着方法的调用完毕而消失 4)初始化值不同 成员变量 :有默认的初始化值 局部变量 :没有默认的初始化值，必须先定义，赋值，才能使用。
3.匿名对象匿名对象：就是没有名字的对象。 是对象的一种简化表示形式 3.1匿名对象的两种使用情况 1)对象调用方法仅仅一次的时候 2)作为实际参数传递
4封装概述 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 好处： 隐藏实现细节，提供公共的访问方式 提高了代码的复用性 提高安全性。 封装原则： 将不需要对外提供的内容都隐藏起来。 把属性隐藏，提供公共方法对其访问。 通过学生案例，给年龄赋值为负数引出数据问题。通过private解决这个问题。最后 这就是封装。
class Student { public void show() { System.out.println(“show”); } } class StudentDemo { //如果参数是一个类名，那么实际需要的是一个具体的对象 public void method(Student s) { s.show(); } } class StudentTest { public static void main(String[] args) { StudentDemo sd = new StudentDemo(); Student s = new Student(); sd.method(s); //多个匿名对象的写法 new StudentDemo.method(new Student()); } } 1:new Student().show(); 2:new StudentTest().method(new StudentDemo()); private关键字 private关键字： 是一个权限修饰符。 可以修饰成员(成员变量和成员方法) 被private修饰的成员只在本类中才能访问。 private最常见的应用： 把成员变量用private修饰 提供对应的getXxx()/setXxx()方法
//一个标准类的写法 class Student2{ //成员变量 //姓名 private String name ; //性别 private String gender ; //年龄 private int age ; //学号 private String id;
//提供对外的公共访问方法:seXXX()/getXXX() //给name设置 public void setName(String n) { //n 局部变量 name = n ; } //获取年龄的值 public String getName(){ return name ; } //性别的设置和获取 public void setGender(String g){ gender = g ; } public String getGender(){ return gender ; } //年龄 public void setAge(int a){ age = a ; } public int getAge(){ return age ; } //id学号 public void setId(String i){ id = i ; } public String getId(){ return id ; } //定义成员方法:显示成员变量 public void show(){ System.out.println("姓名是:"+name+",她的年龄是:"+age+",性别是: "+gender+",她的学号是:"+id) ; }} //测试类 class StudentTest{ public static void main(String[] args){
//需求: 给学生事物的具体对象的成员变量进行赋值 //创建学生对象 Student2 s = new Student2() ; //私有的成员不能访问 //s.name = "张无忌" ; //s.age = 38 ; //给name赋值 s.setName("张无忌") ; s.setGender("男") ; s.setAge(38) ; s.setId("9527") ; //姓名是:张无忌,她的年龄是:38,性别是: 男,她的学号是:9527 s.show() ; System.out.println("--------------------------"); System.out.println(s.getName()+"----"+s.getGender()+"----"+s.getAge()+"-----"+s.getId()); }} this:代表所在类的对象引用 记住： 方法被哪个对象调用，this就代表那个对象 什么时候使用this呢? 局部变量隐藏成员变量,即,局部变量和成员变量同名时,如下: class Student{ //private修饰 private String name ; //此处系统给定的默认值 private int age ;
//提供对外公共访问方法setXXX()/getXXX() //public void setName(String n){ //public void setName(String name){ //当局部变量名称和成员变量名称一致的情况,采用就近原则! // name = name ; //} //使用this改进 public void setName(String name){ this.name = name ; } public String getName(){ return name ; } //public void setAge(int a){ //public void setAge(int age){ // age = age ; //} public void setAge(int age){ this.age = age ; } public int getAge(){ return age ; } //学生学习... public void study(){ System.out.println("Good Good Study,Day Day Up..."); } //将成员变量输出 public void show(){ System.out.println(this.name+"----"+this.age) ; //隐藏this }}
//测试类 class StudentTest{
public static void main(String[] args){ //创建学生类对象 Student s = new Student() ; //s.name = "张无忌" ; s.setName("张无忌") ; s.setAge(30); //输出 //null---0 System.out.println(s.getName()+"---"+s.getAge()) ; s.show() ; }}
4构造方法 4.1构造方法作用:给对象的数据进行初始化 4.1构造方法格式 1)方法名与类名相同 2)没有返回值类型，连void都没有 3)没有具体的返回值 4)构造方法注意事项 如果你不提供构造方法，系统会给出默认构造方法 如果你提供了构造方法，系统将不再提供 构造方法也是可以重载的 4.3:虽然构造方法没有返回值，但是也可以写一个return，在最后写return;这种做法在任何void类 型的方法最后都是没有问题的。 4.4:举例，构造方法的作用给成员变量赋值 类的成员方法 4.4方法具体划分： 根据返回值 有明确返回值方法 返回void类型的方法 根据形式参数 无参方法 带参方法 class Student{ //成员变量 private String name ; private int age ;
//构造方法 //无参构造 public Student(){} //有参构造 public Student(String name,int age){ this.name = name ; this.age = age ; } //成员方法: public void setName(String name){ this.name = name ; } public String getName(){ return name ; } public void setAge(int age){ this.age = age ; } public int getAge(){ return age ; } //学习 public void study(){ System.out.println("学习Java...") ; }}
//测试类 class StudentTest{ public static void main(String[] args){
//方式1:无参构造方法+setXXX() Student s = new Student() ; s.setName("张无忌") ; s.setAge(27) ; s.study(); System.out.println(s.getName() +"---"+s.getAge()) ; System.out.println("---------------------"); //方式2:通过有参构造进行赋值 Student s2 = new Student("扬过",29) ; System.out.println(s2.getName() +"---"+s2.getAge()) ; s2.study(); }} 5,static关键字:前面创建的对象方法中都没有加static,是因为 5.1static的特点: 1)随着类的加载而加载 想一想:main() ---->public static void main(String[] args){} 2)static修饰的变量/方法,优先与对象存在! 回想:对比Student s = new Student(); 完成了哪些事情
3)被static修饰的具有共享,共用(多个对象共同访问同一个static修饰的成员变量) 什么时候去使用static关键字... 举例:类似的这些,都是用static修饰 班级编号(共享) 饮水机 (共享) 水杯(不能被共享的) 4)被static修饰的变量或者成员方法,可以直接被类名调用 5.2 static关键字的注意事项: 1)在静态的方法中是没有this关键字的! 静态优先于对象存在 2)一句话: 静态只能访问静态的变量/方法 非静态的成员方法: 可以访问非静态成员变量,静态的成员变量 可以访问静态的成员方法,非静态的成员方法 5.3 静态的成员方法: 只能访问静态成员变量,只能访问静态成员方法 class Demo2{ public int num = 10 ; public static int num2 = 20 ; //和类有关系 public void method(){ System.out.println(num) ;//10 this.num System.out.println(num2) ;//20 } public static void function(){ //System.out.println(this.num) ; //静态方法中不能存在this //System.out.println(num) ;//无法从静态上下文中引用非静态 变量 num System.out.println(num2); } //非静态的成员方法 public void function2(){ function() ; method() ; } public static void show(){ //method() ; function(); }}
class StaticDemo2{ public static void main(String[] args){ Demo2 d = new Demo2() ; d.method() ;
d.function() ; System.out.println("----------"); d.function2() ; System.out.println("----------"); d.show() ; System.out.println("----------"); int result = sum(100,50) ; System.out.println(result) ; } //求两个数据之和 public static int sum(int a,int b){ return a+b ; }} 例子中num2就是static修饰的静态变量,它可以同时应用在d.function() ;d.function2() ;d.show() ;中. 6.main方法中各个成员的解释如下: main方法的解释:
public static void main(String[] args): jvm识别的程序的入口 public :权限修饰符,公共的,公开的,保证访问权限足够大 static:静态修饰,和类有关系,优先对象存在 void:由jvm调用,没有具体的返回值类型 ,使用void代替 main:方法名, 编程语言,大部分都是有一个程序的入口,Java叫main(主方法) String[] args: 接收字符串数组,参数名args,