第二周学习记录之面向对象
面向对象
基于面向过程的一种思想
面向过程: 代表C语言,强调一个功能的步骤
面向对象: 代表Java语言, 强调对象的创建,使用对象调用功能
生活中处处都是面向对象
举生活的例子:
面向过程:(自己就是执行者)
买电脑
心里清楚电脑的配置----->去赛格电脑城购买电脑----->砍价----> 买到了电脑
洗衣服
脱下脏衣服---->使用洗衣盆放入洗衣液,接水----->泡一泡---->搓一搓---->透一透-----
拧一拧---->晾一晾
炒菜
去买菜---->砍价---->挑菜---->摘菜----->洗菜---->切菜---->起锅烧油----->炒菜---->出锅
面向对象:(自己是指挥者)
买电脑:
看了电脑配置----->让懂行的朋友去买电脑----->买到电脑
洗衣服:
脱下脏衣服----->找一个全自动洗衣机(一键)/对象------>晾一晾
炒菜
饭店---->点菜---->出锅
对象---->出锅
面向对象的思想特点:
1)更符合生活中的思想行为习惯
2)让复杂的事情简单化
3)让我们成从执行者变成了一个指挥者!
面向对象设计原则:
不断创建对象,使用对象,指挥该对象做事情!
面向对象的三大特征:
封装,继承,多态!
类和事物
类 和 事物的关系:
事物:描述现实世界的真实存在泛指的东西!
学生----->学生事物
属性:姓名,年龄,学号,性别
行为:主要学习
类:是描述一组事物的属性和行为的集合
类: 是Java语言的最基本的单元
学生事物 ----------------
属性:描述学生的特征(姓名,年龄,学号,性别)
行为:描述学生能干什么(主要学习)
代码体现出来:类 学生类 class Student{}
成员变量:位置:在类中,方法外 (name,age,studyId,gender)
成员方法:study()
public 返回值类型 方法名(参数){}
代码体系具体事物:创建该类对象
类名 对象名 = new 类名();
对象名.成员变量
对象名.name = "张三" ;
对象名.成员方法()
面向对象的最大特点:强调对象的创建,使用该对象调用自己的功能!
举例:
//定义一个学生类
class Student{
//定义学生类中的属性
String name; //姓名
String sex; //性别
int age; //年龄
int id; //学号
String team; //班级
//定义学生类中的行为
public void eat(){//吃
System.out.println("吃火锅...");
}
public void drink(){
System.out.println("喝快乐肥宅水...");
}
public void paly(){
System.out.println("打篮球...");
}
public void learn(){
System.out.println("学C学Java...");
}
}
//定义一个学生测试类
class StudentTest{
public static void main(String[] args){
//创建类对象
Student student = new Student();
//访问属性
student.name = "史蒂芬.库里";
student.sex = "男";
student.age = 31;
student.id = 312354;
student.team = "金州勇士";
System.out.println("姓名:"+student.name);
System.out.println("性别:"+student.sex);
System.out.println("年龄:"+student.age);
System.out.println("学号:"+student.id);
System.out.println("班级:"+student.team);
System.out.println("--------------------------------");
//访问行为
student.eat();
student.drink();
student.paly();
student.learn();
}
}
成员变量和局部变量
局部变量和成员变量的区别?
1)在类中的位置不同
局部变量:在方法定义中或者是方法声明上的变量
成员变量:在类中,方法外定义的变量
2)在内存中的位置不同
局部变量:在栈内存中存储 跟方法有关
成员变量:在堆内存中存储 跟类的对象有关
3)生命周期不同
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失!
成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完毕,等待垃圾回收器回收掉掉(GC)之后才消失!(不会立即被回收)
4)初始时机不同:
局部变量:在方法定义中或者方法声明上的变量,必须在使用之前进行数据初始化,否则"可能尚未初始化变量"
成员变量:跟对象有关系,在堆内存中,即使这个成员变量没有赋值,系统会根据变量的类型给这个变量进行默认初始化
匿名对象
匿名对象:没有名字的对象
匿名对象的格式
new 类名() ; (前提条件:该类是一个具体类)
特点:
1.仅仅使用一次,使用完毕,从内存中会立即被释放掉
2.匿名对象也可以作为参数进行传递
举例:
/自定义一个学生类
class Student{
public void study(){
System.out.println("好好学习,天天向上!!") ;
}
}
//自定义StudentDemo类
class StudentDemo{
public void method(Student s){//形式参数是一个引用类型,具体类
s.study() ;
}
}
//测试类
class NoNameDemo{
public static void main(String[] args){
//创建StudentDemo类对象 类名 对象名 = new 类名() ;
StudentDemo sd = new StudentDemo() ;
//创建学生类对象
Student s = new Student() ; //对象名称叫s
sd.method(s) ;
System.out.println("-------------------------") ;
//使用匿名对象
sd.method(new Student()) ; //该学生的匿名对象作为参数传递
}
}
封装
private关键字
特点:
1)private可以修饰一个类中的成员变量,也可以成员方法
2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的
举例:
class Demo{
//定义一个成员变量
int num = 10;
private int num2 = 30 ; //私有修饰,只能在Demo类中访问,外界要访问需要通过公共的方法来访问!
//成员方法
public void method(){
System.out.println(num) ;
System.out.println(num2) ;
System.out.println("method demo...") ;
}
//私有的成员方法
private void function(){ //私有的方法,只能在本类中访问
System.out.println("function demo...") ;
}
//公共方法
public void show(){
function() ;
}
}
//测试类
class PrivateDemo{
public static void main(String[] args){
//创建Demo类的对象
Demo d = new Demo() ;
d.num = 50 ; //num成员变量在Demo类中没有被private修饰
System.out.println(d.num) ;
//d.num2 = 100 ; //System.out.println(d.num) ;
//System.out.println(d.num2) ;
System.out.println("-------------------------") ;
d.method() ;
//d.function() ;// function() 在 Demo 中是 private 访问控制
d.show() ;
}
}
标准类的写法
为了区分成员变量和局部变量----java提供了一个关键字:this(代表了当前该类对象地址引用)
setXXX(形参)方法,谁调用这个方法,那么this代表它(地址)
举例:
class Student{
//成员变量私有化
private String name ; //姓名
private int age; //年龄
//提供公共的访问方法赋值 setXXX/getXXX方法 XXX对应的属性名称
//给姓名赋值
public void setName(String name){ //
this.name = name ;//this.name = "庄周"
}
public void setAge(int age){ // age = 25 局部变量
this.age = age ; //this.age = 25
}
//获取姓名
public String getName(){
return name ; //此时获取的name,成员变量的name,隐藏关键了this
//return this.name ; //其实这样的写法 //return "庄周" ;
}
//获取年龄
public int getAge(){
return age ;// return this.age = return 25 ;
}
//其他的成员方法:
public void study(){
System.out.println("学习Java中的面向对象...") ;
}
}
//测试类名
class StudentTest{
public static void main(String[] args){
//创建学生类对象
Student s = new Student() ;
//通过setXXX方法进行赋值
s.setName("庄周") ;
s.setAge(25) ;
System.out.println(s.getName()+"---"+s.getAge());
s.study();
}
}
构造方法
构造方法:
1)方法名和类名相同
2)没有具体的返回值类型
3)并且连void都没有
权限修饰符 + 方法名就是类名(){
}
构造方法主要作用:就是给该对象中的数据进行初始化!
注意事项:
1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,
2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!
(永远建议给出无参构造方法)!
举例:
class Student{
//属性私有化
private String stuId ; //学号
private String name ; //姓名
private int age ; //年龄
private String gender ; //性别
//提供无参构造方法
public Student(){
}
//提供有参构造方法
public Student(String stuId,String name,int age,String gender){
this.stuId = stuId ;
this.name = name ;
this.age = age ;
this.gender = gender ;
}
//提供setXXX()/getXXX()
public void setStuId(String stuId){
this.stuId = stuId ;
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public void setGender(String gender){
this.gender = gender ;
}
//获取值
public String getStuId(){
return stuId ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
public String getGender(){
return gender ;
}
public void study(){
System.out.println("学C学Java...") ;
}
public void sleep(){
System.out.println("累了,睡会吧") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//测试学生类
//方式1:无参构造方法+setXXX:赋值
Student s = new Student() ;
s.setStuId("30");
s.setName("库里");
s.setAge(31) ;
s.setGender("男") ;
System.out.println(s.getStuId()+"----"+
s.getName()+"----"+s.getAge()+"----"+
s.getGender());
s.study();
s.sleep();
System.out.println("--------------------------");
//方式2:通过有参构造方法赋值 (构造方法目的:对对象的数据进行初始化)
Student s2 = new Student("30","库里",31,"男") ;
System.out.println(s2.getStuId()+"----"+
s2.getName()+"----"+s2.getAge()+"----"+
s2.getGender());
s2.study();
s2.sleep();
}
}
成员方法
成员方法的分类:
两种情况:
要么有返回值类型
1)有返回值类型,并且有参数
2)有返回值类型,没有参数
要么没有具体返回值:void代替
1)没有返回值类型,带参
2)没有返回值类,不带参
class StudentDemo{
//定义成员方法
//有返回来类型的情况
//有返回值,带参
public String method(String str){
return "hello"+str;
}
//有返回值,不带参的
public String function(){
return "hello JavaEE" ;
}
//没有返回值类型的情况
//没有返回值带参的 :void代替返回值类型
public void show(int num){
System.out.println(num);
function2() ;
}
//没有返回值,不带参的
private void function2(){
System.out.println("function2 StudentDemo") ;
}
}
//测试类
class MethodDemo{
public static void main(String[] args){
//访问这些成员方法:
//创建对象 :类名 对象名 = new 类名();
StudentDemo sd = new StudentDemo() ;
String result = sd.method("world") ;
System.out.println(result) ;
String s2 = sd.function() ;
System.out.println(s2) ;
sd.show(100) ;
//sd.function2() ;//function2() 在 StudentDemo 中是 private 访问控制
}
}
static关键字
特点:
1)被static修饰的变量/方法 都随着类的加载而加载
class xxx{} ----> 通过javac 编译xxx.java文件 --->编译没有问题(Java语法校验)
---->产生xxx.class文件
java xxx类
2)被static修饰的 优先于对象存在
回想main :被静态修饰符: jvm调用它
public static void main(String[] args){
}
3)被static修饰的可以被多个对象共用
有共享,共用
举例:
班级的编号(同一个班级的都在共用编号)
水杯(不能被共用)
4)被静态修饰的成员变量或者成员方法 ,
可以被类名直接访问(推荐访问方式)
类名.成员方法;
类名.成员方法();
class StaticDemo{
public static void main(String[] args){
Demo d = new Demo() ;
//访问非静态的成员变量,成员方法
System.out.println(d.num) ;
d.show();
System.out.println("-------------") ;
//对象名来访问静态成员
System.out.println(d.num2) ;
d.method();
System.out.println("-------------") ;
//推荐方式:静态成员 直接使用类名访问(static静态的随着类的加载而加载)
System.out.println(Demo.num2) ;
Demo.method();
}
}
使用static关键字的注意事项:
1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的
和类有关系);
2)关于成员方法的访问问题:
非静态的成员方法
既可以访问静态的成员变量,也可以访问非静态的成员变量
既可以访问静态的成员方法,也可以访问非静态的成员方法;
静态的成员方法
简单记:静态只能访问静态
本文地址:https://blog.csdn.net/weixin_48340270/article/details/107574551
上一篇: JDBC框架技术