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,
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
