面向对象编程
java类及类的成员
面向对象的三大特征
其他关键字
1 面向对象与面向过程
OOP:Object OrientedProgramming
POP:ProcedureOrientedProgramming
何为面向对象
打球:
面向过程编写。专注于打球的动作
面向对象编写。打球的动作是归属于谁?人,所以就会出现一个人的对象,人的对象里包含了一个打球的动作
1.1 java类及类的成员
可以用java语言来描述万事万物,把万事万物抽象成一个个的class类
人有什么属性,高矮胖瘦婚否等……
人的行为动作,吃饭,上班,睡觉
用面向对象的思想去分析
类:司机,列车
方法:
司机{紧急刹车(){} }
列车{ 刹车(){}}
类:我,门
方法:
我{关(门)}
门{开门(){} 关门(){} }
类可以只有属性也可以只有方法
2 java语言的基本元素:类和对象
2.1 类的语法格式
2.2 创建Java自定义类
package com.qxcto;
/**
* 人
* @author qx
* 2022-02-07
*/
public class Person {
//属性,成员变量,类的成员变量可以先声明不用初始化
//因为类成员变量有默认值,String类型的默认值是null
String name;
int age;//int的默认值0
//行为,方法(函数)
/**
*打印姓名
*/
public void showName(){
//方法的名称如果是多个单词,首个单词的首字母小写,其他的单词首字母大写
System.out.println("姓名:"+ name);
}
/**
* 获取年龄
* @return
*/
public int getAge(){
//如果是一个有返回值的方法,
// 那么方法体(就是方法后大括号里的所有东西)的最后一行一定是返回相应的数据
//使用的是return关键字,返回的数据类型与方法定义的一致
return age;
}
}
package com.qxcto;
/**
* 2022-02-07
* @author qx
*/
public class Animal {
String name;
int eye;//描述眼睛个数
int legs;
/**
* 输出动物吃的食物
* @param food
*/
public void eat(String food){//方法的参数
System.out.println("此种动物的食物是:"+ food);
}
/**
* 移动方式
* @param moveType 移动方式
*/
public void move(String moveType){
System.out.println("此种动物的移动方式是:"+ moveType);
}
}
2.3 对象的创建及使用
package com.qxcto;
public class Test2 {
public static void main(String[] args){
//实例化Person类,也就是创建Person对象
//int i = 0;
Person person = new Person();
//声明一个Person类型的变量,变量名person
//实例化Person类并且给person赋值,赋值的值就是当前的实例
//new Person()就是实例化Person类
person.name = "张三";//给person对象的name属性赋值
person.showName();//对象的方法调用
int i = person.getAge();//有返回值的方法,,在调用之后就会有一个值,这个值就是方法中return的那部分
System.out.println(i);
person.age = 11;//给person对象的age属性赋值
int a = person.getAge();
System.out.println(a);
}
}
对于类的使用就两个地方,操作类的变量,调用类的方法
3 类的成员之一:属性
3.1 public和private区别
public class Person1 {
public String name = "李四";//public公有的,这样的类变量可以在类的外部使用,也可以在本类的方法使用
private int age;//private私有的,可以在本类的方法使用,不能在类的外部使用
//修饰符可以用来修饰变量,可以指明变量是一个共有还是私有
public void showAge(){
System.out.println(age);
}
}
3.2 static修饰的变量
方法就是函数
代码块直接在类里写一个大括号
实例变量就是在类实例化成对象后才能使用的
static意思是静态的,无需实例化可直接使用
3.3成员变量和局部变量的区别
局部变量没有默认初始化
4 类的成员之二:方法
有(无)参数有(无)返回值的类型
5 对象的创建和使用
package com.qxcto;
public class Student {
String name;
int age;
String course;
String interest;
public void showInformation(){
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("参加的课程:"+course);
System.out.println("兴趣:"+interest);
}
}
package com.qxcto;
public class Teacher {
String name;
int age;
String course;
int teachingAge;
public void showInformation(){
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("教授的课程:"+course);
System.out.println("教龄:"+teachingAge);
}
}
Student stu = new Student();
Teacher tea = new Teacher();
stu.name = "学生1";
tea.name = "教师1";
stu.age = 17;
tea.age = 35;
stu.course = "高等数学";
tea.course = "Java语言编程";
stu.interest = "滑雪";
tea.teachingAge = 10;
stu.showInformation();
tea.showInformation();
6 再谈方法
6.1 什么是方法
6.2 方法的调用
在测试类中写一个和main函数同等级的方法,然后在main方法中实例化本类然后调用
同一个类中,所有的方法可以直接互相调用,不用new去实例化对象
6.3 对象的产生
String为引用类型
测试查看类中不同类型成员变量的默认值
6.4 匿名对象
package com.qxcto;
public class Person2 {
public String name;
public int age;
public String sex;
public void study(){
System.out.println("studying");
}
public void showAge(){
System.out.println("age:"+age);
}
public int addAge(int i){
age += i;
return age;
}
}
//主函数内
Person2 p = new Person2();
p.name = "lisa";
p.age = 11;
p.sex = "女";
p.study();
int a = p.addAge(2);
System.out.println(a+" "+p.age);
package com.qxcto;
public class Circle {
int radius;//半径
//圆面积
public double area(){
return 3.1415*radius*radius;
}
//圆周长
public double perimeter(){
return 2*3.1415*radius;
}
}
Circle c1 = new Circle();
c1.radius = 3;
System.out.println("圆的面积"+c1.area());
System.out.println("圆的周长"+c1.perimeter());
注意:同类和不同类的访问机制
static修饰的方法只能访问static修饰的变量,普通变量不可以
6.5 方法的参数
6.5.1 方法的重载
//多个相同名称的方法如果想在一个类中共存
//那么这些同名方法一定是参数的个数或者参数的数据类型不一样
//这样的同名方法就叫做重载
public int add(int x,int y){
return x + y;
}
public double add(double x, double y){
return x + y;
}
public int add(int x ,int y ,int z){
return x+y+z;
}
//2.mOL
package com.qxcto;
public class Test(){
public static void main(String[] args){
Test2 t2 = new Test2();
t2.mOL(3);
t2.mOL(4,6);
t2.mOL("嗯嗯");
}
public void mOL(int i){
System.out.println(i*i);
}
public void mOL(int i,int j){
System.out.println(i*j);
}
public void mOL(String s){
System.out.println(s);
}
}
//3.max
//主函数体
Test2 t2 = new Test2();
System.out.println(t2.max(5,17));
System.out.println(t2.max(4.7,14.89));
System.out.println(t2.max(4,7,34));
}
public int max(int x ,int y){
return x>y?x:y;
}
public double max(double x,double y){
return x>y?x:y;
}
public double max(double x,double y ,double z){
return x>y?(x>z?x:z):(y>z?y:z);
}
6.5.2 体会可变个数的形参
-
思路1:形参部分定义数组名
-
用数组的方式来传递可变个数的参数
Person类中定义方法
Test,main中调用,传参只能传数组名或者定义数组,不可传元素串(类似“1214”,“呵呵”,“enen”)
如果没有参数,就要定义一个空数组或者是null
-
思路2:形参部分定义…
-
用Java特有的…的方式来传递可变个数的参数,这种参数在使用时与数组的使用方式相同
Person类中定义方法
Test,main中调用,可以传数组名或元素串(“14124”,“efdsdaf”,“2ef2w呵呵”)
如果没有参数可以不填
-
如果一个方法有多个的形参,可变的形参(…这种的形参)一定要放在所有的参数最后
6.5.3 方法的参数传递
方法只有被调用才有意义
JVM(Java虚拟机)
栈中存放对象的引用地址,真正的对象在堆中存放
- 基本数据类型,值是保存在栈中。引用对象,值是保存在堆中,栈中存的对象在堆中的地址。
方法的参数传递之基本数据类型
基本数据类型在参数的传递过程中,就是把实参的值复制值到形参上。
先执行的int a = 0,在栈中开辟了一块内存,地址就是AD8500(假设),存的值是0
调用swap方法,执行int i部分,开辟一块内存,地址是AD8600,值就是从i那里复制过来的值0,执行swap的方法体里面的代码,i = 6,把i在栈中的值再改成15,最终i在栈中的值为15
public static void part(int i ){
i = 15;
System.out.println("part方法内i="+i);//15
}
public static void main(String[] args){
int a = 0;
part(a);
System.out.println("main方法内a="+i);//0
}
方法的参数传递之引用对象
1.DataSwap ds = new DataSwap(),把new DataSwap()存到了堆内存中,地址BE2500
2.ds引用对象存到栈中,地址是AD9500,值是new DataSwap()对象在堆中的地址BE2500
3.调用swap方法,给ds1引用对象保存到栈中地址是AD9600,存的值是来源于实参(ds),就是ds的栈中存的值,这个值实际上就是之前new DataSwap()在堆内存中的地址
到第3步,实际上,ds,ds1其实都是指向同一个对象,这个对象就是在堆内存中地址是BE2500上保存的new DataSwap对象
ds和ds1是引用对象,存的是对象实际在堆中的地址
堆中是对象实际存储的地方
在这个例子中,最后的结果是ds和ds1操作实际上是同一个对象
总结方法的参数传递
1.如果方法的形参是基本数据类型,那么实参(实际的数据)向形参传递参数时,就是直接传递值,把实参的值复制给形参。
2.如果方法的形参是对象,那么实参(实际的对象),向形参传递参数时,也是把值给形参,这个值是实参在栈内存中的值,也就是引用对象在堆内存中的地址
基本数据类型都是保存在栈内存中,引用对象在栈内存中保存的是引用对象的地址,那么方法的参数传递是传递值(是变量在栈内存的值)
7 面向对象特征之一:封装和隐藏
我们需要对这样不能让调用者随意使用的属性做封装和隐藏
设为私有,提供方法增加逻辑控制让调用者有限制的设置
先把属性设置声明私有的,用private关键字。
通过编写public类型的setXXX()和getXXX()方法来设置属性和获取属性,比如对age和set方法,那么方法名就setAge,getAge
四种访问权限修饰符
一个java文件中可以写多个类,只有一个能写public
- T0 为缺省类,在不同包下找不到
- 缺省情况
子类中
- protected
任何地方举例,不同包下,导包后依然找不到
public class Person(){
private age;
public void setAge(int i){
if(i>=0&&i<=130)
{
age = i;
}else{
System.out.println("输入的年龄"+i+"不在0-130之间");
}
}
public int getAge(){
return age;
}
}
public class TestPerson(){
Person b = new Person();
b.setAge(140);
Syetem.out.println("当前设置的年龄为:"+b.getAge());
b.setAge(40);
Syetem.out.println("当前设置的年龄为:"+b.getAge());
}
8 类的成员之三:构造器(构造方法)
- 自己写的是显示构造方法
- 带参数的构造方法
public class Person{
private int age;
public Person(){
age = 18;
}
}
public class Person{
private int age;
private String name;
public Person(int a,String n){
age = a;
name = n;
}
}
package com.day06;
public class Point {
private int x;
private int y;
private int z;
public Point(int a,int b,int c){
x = a;
y = b;
z = c;
}
public void setPoint(int a,int b,int c){
x = a;
y = b;
z = c;
}
public void printInfo(){
System.out.println(x+","+y+","+z);
}
}
/**
*main方法中调用
*/
Point p = new Point(3,4,6);
p.printInfo();
p.setPoint(23,56,78);
p.printInfo();
package com.day06;
public class TriAngle {
private double base = 6.7;
private double height = 13.89;
public double area(){
return (base*height)/2;
}
}
public class TestTriAngle{
public static void main(String[] args){
TriAngle t1 = new TriAngle();
System.out.println(t1.area());
}
}
构造器重载
构造器也叫构造方法,既然是方法就可以重载
/**
* 构造器的重载,就是为了方便调用方可以灵活的创建出不同需要的对象
* 重载的多个构造方法实际上就是相当于提供了多个初始化new对象的模板
*/
public Person5(){
age = 1;
name = "张三";
}
public Person5(int a){
}
public Person5(String s){
}
public Person5(int a,String n){
age = a;
name = n;
}
//main方法
new Person5();
new Person5(1);
new Person5("45765");
new Person5(5,"34567");
public class Person{e
private String name;
private int age;
String school;
String major;
public Person(String n, int a){
name = n;
age = a;
}
public Person(String n,int a, String s){
name = n;
age = a;
school = s;
}
public Person(String n,int a, String s,String m){
name = n;
age = a;
school = s;
major = m;
}
}
//main函数体内
Person p1 = new Person("裴珠泫",13);
Person p2 = new Person("裴秀智",18,"高中");
Person p3 = new Person("孙艺珍",28,"大学","演艺");
9 几个关键字:this、package、import
this★
this不可以在static修饰的方法里用
因为static方法可不作用于对象,而this作为指代对象,用于对对象操作的方法,两者冲突
//Girl.java
package com.qxcto;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
public class Girl {
public Girl(){
System.out.println("无参构造");
}
public Girl(String n){
this.name = n;
System.out.println("名字为:"+this.name);
}
String name;
public void setName(String i){
this.name = i;
}
public String getName(){
return this.name;
}
public void marry(Boy boy){
System.out.println(this.name+"丈夫是:"+boy.name);
}
}
//Boy.java
package com.qxcto;
public class Boy {
public Boy(String n ,int a){
this.name = n;
this.age = a;
System.out.println("姓名为:"+this.name+",年龄为"+this.age);
}
public Boy(String n){
this.name = n;
System.out.println("姓名为:"+this.name);
}
public String name;
public int age;
public void setName(String i){
this.name = i;
}
public String getName(){
return this.name;
}
public void setAge(int i){
this.age = i;
}
public int getAge(){
return this.age;
}
public void marry(Girl girl){
System.out.println(this.name+"妻子是:"+girl.name);
}
public void shout(){
System.out.println(this.name+"shout");
}
}
//main
Girl g1 = new Girl("秀智");
Girl g2 = new Girl();
Boy b1 = new Boy("玄彬",40);
Boy b2 = new Boy("哈尔");
b2.marry(g1);
g1.marry(b1);
b2.shout();
JavaBean
写好私有属性后快速生成get,set方法
选中想要生成方法的属性,ctrl可以多选
自动生成成功
package day06;
/**
* 一个javaBean
* 私有的属性
* 属性对应的get和set方法
*/
public class Person {
private String name;//姓名
private int sex;//1男,0女
private int age;//年龄
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setSex(int sex){
this.sex = sex;
}
public int getSex(){
return this.sex;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
}
package
问题,在使用电脑时,如果不建文件夹,所有的文件都直接放在D盘下。
乱,根本分不清哪些文件是属于哪些软件
其次,同名文件,qq的软件里面有一个名叫data的文件,微信中也有一个data文件。同名文件在同一个文件夹下无法处理。
在java中包的概念就是和文件夹的概念类似,同样,包的存在也是为了解决以上问题(文件太乱不好管理和文件同名)
选择包下的.java加ctrl键可以拖拽到其他包,包下再建包,命名为上层包名.自己包名
java中的包package等同于文件夹的概念,包和文件夹一样可以有多级,也就是包下可以有包和文件,多级的包使用.分隔,例如com包下的cn包下的test包,写法就是com.cn.test
同一个包底下,文件不重名即可
使用同一个包下的类,可以不import
import
这个是使用不同的包底下的java类的一个方式
java.lang包参考
下图转载
- 使用别的包下的类
1.自己手动写import导要用的类
2.直接使用后Alt+Enter自动添加导包的import句
3.不用import
4.导整个包,包括其中所有的java类
JDK中主要的包的介绍