目录
一.类和对象
1.类：是一组相关属性和行为的集合，可看作是一张对象的设计图
对象：创造出的实体
2.Java中要创建对象，必须有类的存在
3. 一个类可以创建多个对象
4. 类的组成
- 属性（名词）：使用成员变量表示
成员变量：跟定义变量的格式一样，但是位置需要放在方法的外面
- 行为（动作）：使用成员方法表示
成员方法：跟定义方法的格式一样，但是需要去掉static关键字
public class Student{
String name = "张三"；
int age = 23；//成员变量
public void study(){
System.out.println("学习Java")；
}
public void eat(){
System.out.println("吃饭")；
}//成员方法
}5.类的本质：对事物进行描述
6.测试类：带有主方法的类
7.格式
创建对象：类名 对象名 = new 类名();
示例：
Student stu1 = new Student();
使用对象成员变量：对象名.成员变量；
stu1.name;
使用对象成员方法：对象名.成员方法();
stu1.study();
public class StudentTest {
public static void main(String[] args){
Student stu1 = new Student();
System.out.println(stu1.name);
System.out.println(stu1.age);
stu1.study();
stu2.eat();
}
}public class PhoneTest {
public static void main(String[] args) {
Phone p1 = new Phone();
pl.brand ="小米";
p1.color = "白色":
p1.price = 4999;
System.out.println(p1.brand + "---" + p1.color + "---" + pl.price);
Phone p2 = new Phone() ;
p2.brand = "华为";
p2.color = "黑色";
p2.price = 6999:
System.out.println(p2.brand + "---" + p2.color + "---" + p2.price);
}
}8. 细节
1）打印对象名，可以看到对象的内存地址
全类名：包名+类名
2）成员变量没有赋值也可以直接用，使用的是对象的默认值，可在使用成员变量的时候赋值
二.对象内存图
1.类的字节码文件进入方法区，先加载有主方法的类文件，字节码文件根据源文件加载
2.主方法会被虚拟机调入栈内存
3.出现new，会进入堆内存，在里面开辟空间，传回地址，空间里有成员变量和成员方法的引用地址，引用地址指向方法区
4.方法执行的时候进栈，执行完出栈
5.不同的对象使用的是内存中相互独立的内存空间，互不打扰
6.一个类的不同对象调用的是同样的成员方法
三.成员变量和局部变量
public class Student {
String name;//成员变量
int age;
}
public class Test{
public static void main(String[] args){
int numl = 10;//局部变量
}
}
public class Student {
public void method(){
int num2 = 20;//局部变量
}
}四.this关键字
1.局部变量和成员变量重名时，Java使用就近原则
public class Student {
String name;//成员变量
public void sayHello(String name) {
System.out.printin(name);//局部变量
}
}
--------------------------------------------------------------
public class ThisDemo {
public static void main(String[] args){
Student stu = new Student();
stu.name ="钢门吹雪";
stu.sayHello( name:“西城狂鸭");//根据就近原则，最终打印局部变量“西域狂鸭”
}
}2.重名时使用this变量区分
3.作用:可以调用本类的成员(变量，方法)
this.本类成员变量
this.本类成员方法();
public void Hello(String name)
{
this.name=name;//把局部变量的值赋给本地变量
}
4.this的省略规则
本类成员方法：没有前提条件，this可以直接省略
本类成员变量：方法中没有出现重名的变量
4.this代表当前类对象的引用（地址）
5.哪一个对象调用的方法，方法中的this代表的就是哪一个变量
五.构造方法
1.定义：构建、创造对象的时候所调用的方法
2.格式
1）方法名与类名相同，大小写一致
2）没有返回值，也没有void
3）没有具体的返回值（不由return带回结果数据）
public class Movie {
private int id;
private String title;
private String time;
private String area;
private String type;
private String director;
private String starring;
private double score;
//空参构造方法
public Movie() {
}
//带参构造方法
public Movie(int id, String title, String time, String area, String type, String director, String starring, double score) {
this.id = id;
this.title = title;
this.time = time;
this.area = area;
this.type = type;
this.director = director;
this.starring = starring;
this.score = score;
}
}
3.构造方法的执行时机
在创建对象的时候被执行调用，每创建一个对象，就会执行一次构造方法
4.作用：可以创建对象的时候，给对象的数据初始化
5.注意事项
1）当没有给出构造方法时，系统会提供一个默认的，无参数的构造方法
2）一个类当中，手动给出了构造方法，系统不会再提供无参构造方法
最好全部手动写出构造方法
3）构造方法不能手动调用
4）构造方法允许重载方法出现
六.封装
1.面向对象三大特征：封装，继承，多态
2.定义：使用类设计对象的时候，将需要处理的数据和处理这些数据的方法，设计到对象中
3.好处：更好的维护数据；
使用者无需关心内部实现，只要知道如何使用即可。
4.设计规范：合理隐藏，合理暴露
5.权限修饰符（可修饰成员变量和方法）
| 修饰符 | 类本身 | 同一个包的类 | 不同包的子类 | 任何类 |
| private | √ | |||
| 默认 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
6.私有成员变量可以保证数据的安全性
针对私有成员变量，提供对应set...（设置）和get...（获取）方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}7.标准Javabean
1）这个类中成员变量都要私有，并且要对外提供相应的get...和set...方法
2）类中要提供无参，带参构造方法
3）只负责存取数据，而对数据的处理交给其他类来完成，以实现数据和数据业务处理相分离
七.API
1）定义：应用程序编程接口
2）其他API（不完整）
3）API帮助文档的使用流程
1.在索引位置搜索自己要查看的类
2.看包
目的: 是不是iava.lang包(核心包)，不需要编写导包代码 (import)- 不是java.lang包，都需要编写导包代码
3.看这个类的介绍
目的: 搞清楚这个类的作用
4.看这个类的构造方法
目的: 为了将该类的对象，创建出来
5.看这个类的成员方法(方法摘要)
方法名，参数，返回值，介绍
八.static关键字
1.修饰成员变量和成员方法
2.特点
1）数据被所有类的对象所共享
2）可以直接通过类名调用（推荐）
例： Student.school
public class Student {
int age;
String name;
static String school;//将school数据设为静态变量
public void eat() {
System.out.println("学生需要吃饭");
}
public void sleep() {
System.out.println("学生需要睡觉");
}
public void Hello(String name) {
this.name = name;
}
public void print() {
System.out.println(this);
}
}
public class StudentTest {
public static void main(String[] args){
Student stu1 = new Student();
stu1.name ="张三";
stu1.age = 23;
Student.school="传智专修学院";//直接通过类名进行调用
System.out.println(stu1.name + "---" + stu1.age + "---"+ Student.school);
System.out.println("-------");
Student stu2 = new Student();
stu2.name ="李四";
stu2.age = 24;
System.out.println(stu2.name + "---" + stu2.age + "---" + Student.school);
}
}3）随着类的加载而加载，优先与对象存在，在创建对象前就可以使用
4）静态成员变量在堆内存中有单独空间
3.static修饰成员方法
1）常用于制作工具类，使调用更加方便
工具类：不描述事情，只完成一些事情
2）一个类中所有方法都是static修饰，要私有该类的构造方法
目的：不让其他类再创建对象
4.注意事项：
静态方法只能访问静态成员（直接访问）
非静态成员在创建对象后才能使用
public class StaticDemo2{
static int num1 = 1;//静态成员
int num2 = 20;//非静态成员
public static void method()
{
System.out.printin("static...method");
}
public static void main(String[] args) {
// 在静态方法中，只能访问静态成员(直接访问)
System.out.printIn(num1);//可访问num1，而不能访问num2
method();
}
}
不允许使用this关键字（对象还未创建）
只能静态访问静态数据
九.练习
机票查询系统
public class Airticket {
public static String company = "中国南方航空";
private int score;
private double price;
private String time;
private String elapsedtime;
private String process;
public Airticket() {
}
public Airticket(int score, double price, String time, String elapsedtime, String process) {
this.score = score;
this.price = price;
this.time = time;
this.elapsedtime = elapsedtime;
this.process = process;
}
/**
* 获取
* @return score
*/
public int getScore() {
return score;
}
/**
* 设置
* @param score
*/
public void setScore(int score) {
this.score = score;
}
/**
* 获取
* @return price
*/
public double getPrice() {
return price;
}
/**
* 设置
* @param price
*/
public void setPrice(double price) {
this.price = price;
}
/**
* 获取
* @return time
*/
public String getTime() {
return time;
}
/**
* 设置
* @param time
*/
public void setTime(String time) {
this.time = time;
}
/**
* 获取
* @return elapsedtime
*/
public String getElapsedtime() {
return elapsedtime;
}
/**
* 设置
* @param elapsedtime
*/
public void setElapsedtime(String elapsedtime) {
this.elapsedtime = elapsedtime;
}
/**
* 获取
* @return process
*/
public String getProcess() {
return process;
}
/**
* 设置
* @param process
*/
public void setProcess(String process) {
this.process = process;
}
}
package test;
import domain.Airticket;
import domain.Movie;
import java.util.Scanner;
public class AirticketService {
private Airticket[] tickets;
private Scanner sc = new Scanner(System.in);
public AirticketService(Airticket[] tickets) {
for (int i = 0; i < tickets.length; i++) {
this.tickets = tickets;
}
}
public void start() {
lo:
while (true) {
System.out.println("------机票查询系统（5月1日长春到武汉）------");
System.out.println("请输入您的选择");
System.out.println("1.查询全部机票信息");
System.out.println("2.查询推荐指数最高机票");
System.out.println("3.查询价格最低机票");
System.out.println("4.退出");
int choice = sc.nextInt();
switch (choice){
case 1:
alltickets();
break;
case 2:
System.out.println("推荐指数：4------价格：796.0-----时间：16:40—19:50------旅途时长：3h10m------旅途过程：无需中转");
break;
case 3:
System.out.println("推荐指数：3------价格：591.0-----时间：9:50—18:40------旅途时长：8h50m------旅途过程：需要中转");
break;
case 4:
System.out.println("感谢您的使用，再见！");
break lo;
default:
System.out.println("您的输入有误，请检查");
break;
}
}
}
private void alltickets(){
for (int i = 0; i < tickets.length; i++) {
Airticket airticket= tickets[i];
System.out.println("推荐指数："+airticket.getScore()+"------"+"价格："+airticket.getPrice()+"-----"+"时间："+
airticket.getTime()+"------"+"旅途时长："+airticket.getElapsedtime()+
"------"+"旅途过程："+airticket.getProcess()+"------"+"航空公司:"+Airticket.company);
}
}
public void best() {
int[] score = {3, 4, 2, 2, 2};
int max = score[0];
for (int i = 1; i < score.length; i++) {
if (max < score[i]) {
max = score[i];
}
}
System.out.println();
}
}
package test;
import domain.Airticket;
import test.AirticketService;
public class AirticketTest {
public static void main(String[] args){
Airticket airticket1 = new Airticket(3,591,"9:50—18:40","8h50m","需要中转");
Airticket airticket2 = new Airticket(4,796,"16:40—19:50","3h10m","无需中转");
Airticket airticket3 = new Airticket(2,1016,"3:25—18:20 ","4h55m","需要中转");
Airticket airticket4 = new Airticket(2,1105,"19:00—22:15","3h15m","无需中转");
Airticket airticket5 = new Airticket(2,1200,"16:15—19:30","3h15m","无需中转");
Airticket[] tickets = {airticket1,airticket2,airticket3,airticket4,airticket5};
AirticketService airticketService = new AirticketService(tickets);
airticketService.start();
}
}
输出结果：
------机票查询系统（5月1日长春到武汉）------
请输入您的选择
1.查询全部机票信息
2.查询推荐指数最高机票
3.查询价格最低机票
4.退出1
推荐指数：3------价格：591.0-----时间：9:50—18:40------旅途时长：8h50m------旅途过程：需要中转------航空公司:中国南方航空
推荐指数：4------价格：796.0-----时间：16:40—19:50------旅途时长：3h10m------旅途过程：无需中转------航空公司:中国南方航空
推荐指数：2------价格：1016.0-----时间：3:25—18:20 ------旅途时长：4h55m------旅途过程：需要中转------航空公司:中国南方航空
推荐指数：2------价格：1105.0-----时间：19:00—22:15------旅途时长：3h15m------旅途过程：无需中转------航空公司:中国南方航空
推荐指数：2------价格：1200.0-----时间：16:15—19:30------旅途时长：3h15m------旅途过程：无需中转------航空公司:中国南方航空
------机票查询系统（5月1日长春到武汉）------
请输入您的选择
1.查询全部机票信息
2.查询推荐指数最高机票
3.查询价格最低机票
4.退出
2
推荐指数：4------价格：796.0-----时间：16:40—19:50------旅途时长：3h10m------旅途过程：无需中转
------机票查询系统（5月1日长春到武汉）------
请输入您的选择
1.查询全部机票信息
2.查询推荐指数最高机票
3.查询价格最低机票
4.退出
3
推荐指数：3------价格：591.0-----时间：9:50—18:40------旅途时长：8h50m------旅途过程：需要中转
------机票查询系统（5月1日长春到武汉）------
请输入您的选择
1.查询全部机票信息
2.查询推荐指数最高机票
3.查询价格最低机票
4.退出
4
感谢您的使用，再见！
1257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
