day07
面向对象
面向对象思想概述
/* A: 面向过程思想概述:
*第一步
*第二步;
B: 面向对象思想概述:
*找对象(第一步,第二步)
C: 举例说明
买煎饼果子
D:面向对象的思想特点:
a: 一种更符合我们思想习惯的思想(懒人思想);
b: 可以将复杂的事情简单化;
c:将我们从执行者变成指挥者;角色发生转换;
E: 面向对象开发
*就是不断创建对象,使用对象,指挥对象做事
F: 面向对象设计
*其实就是在管理和维护对象之间的关系;
G: 面向对象特征:
*封装(encapsulation);
*继承(inheritance);
*多态(polymorphism);
面向对象(类与对象概述)
A: 学习编程是为了什么?
为了把我们日常生活中实物用学习语言描述出来;
B: 我们如何描述现实世界的事物
*属性 就是该事物的描述信息(事物身上的名词);
*行为 就是该事物能够做什么(事物身上的动词);
C: Java中最基本的单位是类,Java中用class描述事物也是如此;
*成员变量 事物的属性;
*成员方法 事物的行为;
D: 定义类其实就是定义类的成员(成员变量和成员方法);
*成员变量 和以前定义变量是一样的,只不过位置发生了改变,在类中,在方法外;
*成员方法 和以前定义方法一样,只不过把static去掉
E: 类和对象的概念
a: 类: 是一组相关的属性和行为的集合;
b: 对象: 是该事物的具体体现
类的定义举例
1.学生类
class Student
{
String name; //姓名
int age; //年龄
String gender; //性别
public void study(){
System.out.println("学生学习");
}
public void sleep(){
System.out.println("学生睡觉");
}
}
2.手机类
class phone
{
String brand;
int price;
public void call(){
System.out.println("打电话");
}
public void call(){
System.out.println("sent message");
}
public void call(){
System.out.println("play game");
}
}
类的使用
A: 文件名问题
*在一个java文件中写两个类:一个基本的类,一个测试类;
建议文件名称和测试类名称一致;
B: 如何使用对象?
*创建对象并使用
*格式: 类名 对象名 = new 类名();
D:如何使用成员变量名?
对象名.变量名
E: 如何使用成员方法名?
*对象名.方法名(...)
使用举例
//定义学生类并使用
class Demo1_Student
{
public static void main(String[] args)
{
//创建对象的格式: 类名 对象名 = new 类名();
//对象名其实就是合法的标识符,如果是一个单词所有字母小写,如果是多个单词,从第二个单词开始首字母大写
Student s = new Student();
/*
D:如何使用成员变量名?
对象名.变量名
E: 如何使用成员方法名?
*对象名.方法名(...)
*/
s.name = "张三";
s.age = 23;
System.out.println(s.name + "..." + s.age);
s.study();
s.sleep();
}
}
class Student
{
String name; //姓名
int age; //年龄
String gender; //性别
public void study(){
System.out.println("学生学习");
}
public void sleep(){
System.out.println("学生睡觉");
}
}
//定义手机类并使用对象
class Demo_Phone
{
public static void main(String[] args)
{
Phone p = new Phone();
p.brand = "红米Note7";
p.price = 1499;
System.out.println(p.brand + "..." + p.price);
p.call();
p.sendMessage();
p.playGame();
}
}
class Phone
{
String brand;
int price;
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("send message");
}
public void playGame(){
System.out.println("play game");
}
}
类的内存分配
class Demo3_Car
{
public static void main(String[] args)
{
Car c1 = new Car();
c1.brand = "广汽丰田";
c1.color = "blue";
c1.price = 200000;
c1.run(); //调用行为
Car c2 = new Car();
c2.brand = "奥迪A5";
c2.color = "white";
c2.price = 240000;
c2.run(); //调用行为
//c2 = null ; //NullPointerException 用null把原来的地址值覆盖掉了
//c2.run(); //c2里面的记录是null,所以报出空指针异常
}
}
/*
车的属性:商标,价钱, 颜色
车的行为: 运行,刹车
*/
class Car
{
String color; //属性:颜色
String brand; //属性:商标;
int price; //属性:价格
public void run(){ //车运行 行为
System.out.println(brand + color + price);
}
}
类:一个对象内存分配
类:两个对象的内存分配
堆:如果没有任何引用指向该对象,该对象就会变成垃圾,Java中有完善的垃圾回收机制,会在不定时的进行回收
C语言中需要手动回收;
面向对象(成员变量和局部变量的区别)
A:在类中位置不同
*成员变量:在类中方法外;
*局部变量:在方法定义中或者方法声明上;
B: 内存中的位置不同
成员变量:在堆内存(成员变量属于对象,对象进堆内存);
局部变量:在栈内存(局部变量属于方法,方法进占内存);
C: 生命周期不同
成员变量:随着对象的创建而创建,随着对象的消失而消失;
局部变量:随着方法的调用而存在,随着方法调用完毕而消失;
D: 初始化变量不同
*成员变量,有默认初始化值;
*局部变量:没有默认初始化值,必须定义,赋值,然后才能使用;
*注意事项:
*局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则;
*基本数据类型变量包括:byte,short,int,long,float,double,boolean,char
*引用数据类型变量包括:数组,类,接口,枚举
class Demo2_Person
{
public static void main(String[] args)
{
Person p = new Person();
p.speak();
}
}
class Person{
String name;//成员变量;
int num;
public void speak(){ //x和num都是局部变量
int num = 10;
System.out.println(name);
System.out.println(num);
}
}
方法的形式参数是类名的时候如何调用
A: 方法的参数是类名 public void print (Student s){}//print{new Student()}
如果看到一个方法的形式参数是一个类类型(引用类型),这里需要的其实是该类的对象
####
class Demo7_Student
{
public static void main(String[] args)
{
print(10);
Student s = new Student(); //创建对象,并将对象的地址赋值给s
print(s);
}
public static void print(int x){ //基本数据类型当做形参
System.out.println(x);
}
public static void print(Student s){ //引用数据类型当做形参
s.name = "张三";
s.age = 23;
s.speak();
}
}
class Student
{
String name;
int age;
public void speak(){
System.out.println(name + "..." + age);
}
}
匿名对象的概述和应用
A:什么是匿名对象
没有名字的对象;
B:匿名对象的应用场景
a: 调用方法,仅仅只调用一次的时候;
那么这种代码有什么好处:
节省代码
*注意:调用多次的时候,不适合,匿名对象调用完毕就是垃圾,可以被垃圾回收器回收;
b: 匿名对象可以作为实际参数传递
C:案例演示
匿名对象应用场景
class Demo2_Car
{
public static void main(String[] args)
{
Car c1 = new Car(); //创建有名字的对象;
c1.run();
new Car().run();
//匿名对象调用,匿名对象只适合对方法的一次调用,因为调用多次就会产生多个对象,不如调用有名字的对象;
//匿名对象是否可以调用属性并赋值?有什么意义?
new Car().color = "red";
new Car().num = 4;
}
}
class Car
{
String color;
int num;
public void run(){
System.out.println(color + "..." + num);
}
}
//匿名对象可以当做参数传递
class Demo6_Car
{
public static void main(String[] args)
{
method(new Car());
}
public static void method(Car cc){
cc.color = "red";
cc.num = 4;
cc.run();
}
}
class Car
{
String color;
int num;
public void run(){
System.out.println(color + "..." + num);
}
}
封装
A: 封装概述
*是指隐藏对象的属性和实现细节,仅对外提供公共访问方式;
B: 封装好处
*隐藏实现细节,提供公共的访问方式;
*提高代码的复用性;
*提高安全性;
C: 封装原则
*将不需要对外提供的内容都隐藏起来;
*把属性隐藏,提供公共方法对其访问;
面向对象相关关键字介绍
关键字:private
/*
*A:人类年龄赋值问题
*B:private关键字介绍
*a:是一个权限修饰符;
*b:可以修饰成员变量和成员方法;
*c:被修饰的成员只能在本类中被访问;
*C: 案例演示
*封装和private的应用;
*A:把成员变量用private修饰;
*B:提供对应的getXxx()和setXxx()方法;
*private仅仅是封装的一种体现形式,不能说封装就是私有
*/
class Demo1_Person
{
public static void main(String[] args)
{
Person p1 = new Person();
p1.name = "张三"; //调用姓名属性并赋值
//p1.age = 23; //调用年龄属性并赋值
//p1.speak(); //调用行为
p1.setAge(-17);
System.out.println(p1.getAge());
}
}
class Person {
String name;
private int age;
public void setAge(int a){ //设置年龄
if (a > 0 & a <200)
{
age = a;
}else {
System.out.println("输入年龄不合法");
}
}
public int getAge(){ //获取年龄
return age;
}
public void speak(){
System.out.println("我的姓名是" + name + "..." + "我的年龄是" + age);
}
}
关键字:this
/*
A: this关键字特点
*代表当前对象的引用;
B: 案例演示:
*this的应用场景:
用来区分成员变量和局部变量
*/
class Demo1_This
{
public static void main(String[] args)
{
Person p1 = new Person();
p1.setName("张三");
p1.setAge(23);
System.out.println(p1.getName() + "...." + p1.getAge());
Person p2 = new Person();
p2.setName("李四");
p2.setAge(24);
System.out.println(p2.getName() + "...." + p2.getAge());
}
}
class Person {
private String name;
private int age;
public void setAge(int age){ //设置年龄
if (age > 0 & age <200)
{ //就近原则
this.age = age;
}else {
System.out.println("输入年龄不合法");
}
}
public int getAge(){ //获取年龄
return age;
}
public void setName(String name){
this.name = name;
} //设置姓名;
public String getName(){
return name;
} //获取姓名;
}
案例应用
class Test_Phone
{
public static void main(String[] args)
{
Phone p = new Phone();
p.setBrand("红米note7");
p.setPrice(1399);
System.out.println("手机品牌是" + p.getBrand() + ",价格是" + p.getPrice());
p.call();
p.sendMessage();
p.playGame();
}
}
/*
手机类:
属性:品牌,价格
行为:打电话,发短信,玩游戏
*/
class Phone //java bean
{
private String brand; //品牌
private int price; //价格
public void setBrand(String brand){
this.brand = brand; //设置品牌;
} //获取品牌
public String getBrand(){
return this.brand; //this可以省略,系统会自动添加;
}
public void setPrice(int price){
this.price = price;
}
public int getPrice(){
return price; //省略了this
}
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("send Message");
}
public void playGame(){
System.out.println("playGame");
}
}
构造方法
##A: 构造方法的概述和作用:
*给对象的数据(属性)进行初始化;还可以动态赋值
B: 构造方法格式与特点:
*a: 方法名与类名相同(大小也与类名保持一致);
*b: 没有返回值类型,连void都没有;
*c: 没有具体的返回值return
C: 构造方法的重载(重载:方法名相同,与返回值类型无关)
*构造方法没有返回值;
D: 构造方法的注意事项
*a:如果我们没有给出构造方法,系统将自动提供一个无参数的构造方法;
*b:如果我们给出构造方法,系统将不再提供默认的无参数构造方法;
*注意:这个时候,我们如果还想使用无参数构造方法,就必须自己给出,建议一直自己给出无参数构方法
class Demo3_Person
{
public static void main(String[] args)
{
Person p1 = new Person(); //括号未写内容,空参构造
p1.show();
System.out.println("-----------");
Person p2 = new Person("张三",23); //有参构造
p2.show();
System.out.println("-----------");
Person p3 = new Person("李四",26); //有参构造
p3.show();
}
}
class Person
{
private int age;
private String name;
public Person(){
System.out.println("空参构造");
}
public Person(String name ,int age){
this.name = name;
this.age = age;
System.out.println("有参构造");
}
public void show(){
System.out.println(name + "... " + age);
}
}
给成员变量赋值的两种方法
/*
构造方法
给属性进行初始化;
setXxx方法
修改属性值,
这两种方式,在开发中setXxx更多一些,因为比较灵活;
*/
class Demo4_Person
{
public static void main(String[] args)
{
Person p1 = new Person("张三",23); //有参构造创建对象;
p1 = new Person("张天一",23); //这种方式看运行结果貌似改名了,其实是将原对象变成垃圾
System.out.println(p1.getName() + "...." + p1.getAge());
System.out.println("-----------");
Person p2 = new Person(); //空参构造创建对象
p2.setName("李四");
p2.setName("李鬼"); //改名
p2.setAge(25);
System.out.println(p2.getName() + "...." + p2.getAge());
}
}
/*
构造方法
给属性进行初始化;
setXxx方法
修改属性值,
这两种方式,在开发中setXxx更多一些,因为比较灵活;
*/
class Person
{
private int age;
private String name;
public Person(){
}
public Person(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 this.age; //获取年龄
}
public void show(){
System.out.println(name + "... " + age);
}
}