目录
1.Java语言框架
2. 对比面向过程与面向对象
面向过程和面向对象都是编写应用程序的一种方法。
面向过程是一种以过程(方法)为最小颗粒度的编程语言。一个方法一定声明完成,这个方法的功能就不能改变了。
面向对象是一种以过程中使用的对象为最小颗粒度的编程语言。一个方法声明完成,会根据使用的对象的不同,而改变这个方法的功能。
3 类和对象(语法)
3.1 关系
类和对象之间的关系。必须是从现实世界向软件世界转换的过程。
3.2 创建类(语法)
类Class是一个特殊的数据类型。与int,String本质是一样的。
类中有属性和方法。 例如:学员,手机这些数据类型。
属性:就是变量。
方法:就是我们之前编写的方法。 public static void print(int i);
创建的基本语法:class就是类的关键字。
public class 类名{
}
public class A{
}
3.3 创建对象(语法)
类是一种特殊的数据类型。使用这个类型创建的变量也称为叫对象。
所以使用类创建一个对象时,需要使用new关键字进行实例化。
对象就可以通过打点的方式,调用类型中的属性和方法。
对象名.属性;
对象名.方法();
变量的使用规则 :
声明 | 初始化 | 使用 |
int i; A a; | i = 10; a = new A(); | sout(i); a.属性=值; sout(a.属性); a.方法(); int x = a.方法(); |
public class A {
int i = 10;
public void print(){
System.out.println("这是A类中的一个叫print方法");
}
}
public class Test01 {
public static void main(String[] args) {
//使用A类创建对象a
A a = new A();
a.i = 40;
System.out.println(a.i);
a.print();
}
}
3.4 专有名词
A a = new A();
a 我们叫引用。
new A(); new是实例化,实例化:在内存中创建实例空间的过程。
实例:就是我们内存中开辟的空间。
3.5 对象的内存结构
3.6 属性(语法)
属性 : 一般都是指在类中声明的变量,称为成员变量,也为成员属性。
针对成员属性,我们也叫实例属性。
成员属性:就是在类中声明的变量。
成员属性的作用域: 是受访问修饰符影响的。属性一般使用private。
private 表示私有。表示属性只在声明的这个类中可以使用。
3.7 方法(语法)
方法:成员方法,实例方法。在类中声明的方法。
成员方法的作用域: 方法一般使用public。
public 表示公有。任意位置都可以使用。
成员方法可以用来操作成员属性。
实例属性和实例方法是属于实例的,每一个实例都有自己的实例属性和实例方法。
public class A {
private int age = 10;//成员属性。私有的。可以在本类的任意位置使用。
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//创建一个测试类
A a = new A();
a.setAge(24);
System.out.println(a.getAge());
3.8 JavaBean的规范
一个类如果按JavaBean规范编写,应该具备如下三个要求:
① 默认构造方法
② 私有属性
③ 公有set/get方法
set和get方法的命名格式规范:set和get做前缀,将属性名的首字母大写拼接。
3.9 this关键字
this是我们Java代码中的一个关键字。
this是在实例内部一个指向自身实例的引用。
我们使用this可以指定本类中的属性和方法。
4 类和对象(软件设计)
4.1 类是怎么来的?
类是对现实世界中具有相同属性和相同方法的大量对象的抽象。抽取相同的属性和方法。
抽象将得到属性和方法,再使用{ }封装起来。起个名,用个class关键字。
例如:我们做一个学员管理系统。对现实世界中大量的学员对象,进行抽象,抽属性和方法。
类是模板。
public class Stu {
//有学号
private int sid;
//有姓名
private String sname;
//有睡觉的方法
public void sleep(int hours){
System.out.println(this.sname + "晚上休息了 "+hours+" 小时!");
}
4.2 对象
类是模板,对象是具体的事物。对象是对客观事物的抽象,类是对对象的抽象。类是抽象的,
不占内存,对象是具体的,占用内存。对象是类的实例,类是对象的模板。对象通过new
classname产生的,用来调用类的方法和类的构造方法。
4.3 练习:编写如下的类
1. 编写汽车类
public class Car {
//品牌
private String type;
//价格
private int price;
//跑
public void run(int juli){
System.out.println(this.type+"加满油能跑"+juli+"公里");
}
2. 编写狗类
public class Dog {
// 编号
private int id;
// 品种
private String type;
// 年龄
private int age;
// 性别
private String gender;
public void sleep(){
System.out.println("狗会睡觉");
}
public void eat(){
System.out.println("狗吃骨头");
}
public void call(){
System.out.println("汪汪汪");
}
5 构造方法
构造方法也是一个方法。是类中一个特殊的方法。
5.1 什么是构造方法
一个与类名同名的,并没有返回类型描述的方法。叫构造方法。
public class Stu {
//构造方法
public Stu(){
System.out.println("构造方法!");
}
5.2 构造方法的分类
构造方法有如下几种分类:
① 默认(无参)构造方法:一个没有参数的构造方法。
隐式构造方法:当一个类没有编写构造方法时,系统会自动为这个提供一个默认构造方法。
② 参数化(有参)构造方法:有参数的构造方法。
每一个类都有一个自己的构造方法。
5.3 构造方法的作用
构造方法是在对象被实例化时调用的方法。
在创建实例的过程中一定要调用构造方法来创建我们的对象。
构造方法不用我们指定。系统会根据new关键字后面的类的格式来调用对应的构造方法。
Stu s1 = new Stu();//new关键字时一定要调用构造方法。
系统会按Stu()来调用对应的构造方法。
构造方法的作用是在实例化时为类的属性进行初始化操作。
例:Stu 和Birthday 类的构造方法使用。
public class Stu {
private int sid;
private String sname;
private Birthday birthday ;//被构造方法初始化的属性
//构造方法
public Stu(){
System.out.println("构造方法!");
birthday=new Birthday();
}
//有参构造
public Stu(int sid, String sname,int year, int month, int day){
this.sid = sid;
this.sname = sname;
birthday = new Birthday(year,month,day);
}
//Fn+Alt+Ins键
//set&get
@Override
public String toString() {
return "Stu{" +
"sid=" + sid +
", sname='" + sname + '\'' +
", birthday=" + birthday +
'}';
}
}
public class Birthday {
private int year;
private int month;
private int day;
public Birthday() {
}
public Birthday(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
//set&get
@Override
public String toString() {
return "Birthday{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}
编写测试类:
public class TestStu {
public static void main(String[] args) {
Birthday birthday;
birthday=new Birthday();
birthday.setYear(2001);
birthday.setMonth(4);
birthday.setDay(20);
System.out.println(birthday);
Stu s=new Stu();
s.setSname("嘎嘎嘎");
s.getBirthday().setDay(20);
s.getBirthday().setMonth(4);
s.getBirthday().setYear(2001);
s.setSid(55);
System.out.println(s);
}
}
6 对象创建的过程(扩展)
Stu s = new Stu(); //一个对象创建的完整过程包含二个部分 类加载 和 对象创建。
对象创建过程的步骤:实例化-初始化-引用赋值
① 实例化:内存中开辟实例(Stu),并为每一个属性赋默认值。
② 初始化:调用相应的构造方法(Stu()),来完成对属性的初始化。
③ 引用赋值:将实例的引用赋值给引用(s)。
7 任务:定义一个长方形的类
① 定义一个长方形的类。在这个类中有二个属性长和宽;
② 定义一个计算长方形周长的方法;
③ 定义一个计算长方形面积的方法。
public class React {
private int chang;
private int kuan;
public void zc(){
System.out.println("周长:"+(chang+kuan)*2);
}
public void mj(){
System.out.println("面积:"+(kuan*chang));
}
public React(int chang, int kuan) {
this.chang = chang;
this.kuan = kuan;
}
//set&get
//toString
}
8 面向对象三大特性:封装
封装:在Java中 { }就是封装。
类是对大量对象进行抽象,将相同的属性和方法进行封装形成类。方法是对代码的封装。
封装的好处:
① 隐藏代码细节。使用方法时,只关心格式和作用。不关心代码实现。
② 模块化开发。