一.面向对象
1.概述
封装不同的步骤和功能,使用时直接使用,不必一步步写出
2.特征
封装 :把属性和方法封装到一个类中
继承:子类继承父类
子类对父类方法的覆盖重写和同一个类中的方法的重载
多态:父类引用指向子类对象
重载:同一个类中,方法名相同,参数列表不同,称之为方法的重载,与返回值类型无关
重写:子类对父类方法的覆盖重写,方法名相同,参数列表相同,只是方法的方法体不同.
3.类与对象
属性:就是该事物的描述信息
功能:就是该事物能够做什么
事物 类
属性 ----------------- 成员变量
功能 ----------------- 成员方法
类:是一组相关的属性和行为的集合
对象:是该类事物的具体体现
定义类就是定义类的成员:(1)成员变量:定义在类中,方法外(2)成员方法
4.创建对象
格式:类名 对象名=new 类名();如Person person=new Person();
使用成员变量:对象名.变量名;如person.name;
使用成员方法:对象名.方法名(...);person.eat(){......};
案例一:
Person类
public class Person {
//定义成员变量
int age=22;
String name="马飞飞";
char sex='男';
//定义成员方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void piay(){
System.out.println("玩游戏");
}
}
测试类
public class MyTest {
public static void main(String[] args) {
Person person=new Person();
String name = person.name;
int age = person.age;
char sex = person.sex;
System.out.println(name);//马飞飞
System.out.println(age);//22
System.out.println(sex);//男
System.out.println("=====================");
name="卢本伟";
age=18;
sex='女';
System.out.println(name);//卢本伟
System.out.println(age);//18
System.out.println(sex);//女
}
案例二:
手机类
public class Phone {
//成员变量
String brand="苹果";
double price=3000.0;
String color="白色";
//定义成员方法
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(String name,String content){
System.out.println("给"+name+"发信息"+"内容是"+content);
}
}
测试类
public class MyTest2 {
public static void main(String[] args) {
Phone phone=new Phone();
String brand = phone.brand;
String color = phone.color;
double price = phone.price;
System.out.println(phone);//@1540e19d
System.out.println(brand);//苹果
System.out.println(color);//白色
System.out.println(price);//3000.0
System.out.println("================");
brand="华为";
color="黑色";
price=1000.0;
System.out.println(brand);//华为
System.out.println(color);//黑色
System.out.println(price);//1000.0
}
}
案例三:
成员变量不赋值会有默认值
学生类
public class Student {
String name;
int age;
long id;
double score;
public void study(){
System.out.println("学习");
}
public void eat(){
System.out.println("吃饭");
}
测试类
public class MyTest3 {
public static void main(String[] args) {
/*
成员变量不赋值会有默认值
* */
Student student=new Student();
int age = student.age;
long id = student.id;
String name = student.name;
double score = student.score;
System.out.println(age);//0
System.out.println(id);//0
System.out.println(name);//null
System.out.println(score);//0.0
System.out.println("===============");
age=27;
id=1111111;
name="陈一发";
score=100.0;
System.out.println(age);//27
System.out.println(id);//1111111
System.out.println(name);//陈一发
System.out.println(score);//100.0
}
}
二.对象内存图
1.一个对象的内存图
2.两个对象的内存图
3.三个对象的内存图
三.成员变量和局部变量
1.定义:
成员变量:定义在类中,方法外
局部变量:定义在方法内部或者方法的声明上(形参)
2.区别:
1)
成员变量:成员变量属于对象,随着对象的创建的创建而产生,随着对象的消失而消失。
局部变量:局部变量属于方法,局部变量随着方法的调用而产生,随着方法的调用完毕而消失。
2)
成员变量有默认值
局部变量没有默认值,需要初始化才能使用
3)
成员变量在堆内存
局部变量在栈内存
public class Student {
//定义成员变量
String name;
int age;
//定义局部变量
public void show(String name,int age){
System.out.println(name);
System.out.println(age);
}
}
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.show("张三",20);
}
}
//我们可以在一个Java文件中,并列定义多个类。要求是 只能这个有主方法的类前面加上public,要么全部都不加public
//但是我们建议 一个类就是一个Java文件
class MyTest2{
}
class MyTest3{
}
四.匿名对象
1.定义
没有名字的对象
2.应用场景
调用方法,仅仅只调用一次的时候。
匿名对象可以作为实际参数传递
案例
package org.westos.demo;
public class Student {
//定义成员变量
String name;
int age;
//定义局部变量
public void show(String name,int age){
System.out.println(name);
System.out.println(age);
}
}
package org.westos.demo;
public class MyTest4 {
public static void main(String[] args) {
Student student=new Student();
student.show("里斯",33);
//使用匿名对象,适用于调用方法,仅仅只调用一次的时候。
new Student();
new Student().show("王五",44);
//方法调用多次时,不能使用匿名对象
Student student2=new Student();
student2.show("哈哈哈",88);
student2.show("哈哈哈",88);
student2.show("哈哈哈",88);
}
//匿名对象可以作为参数传递
show2(new Student());
public void show2( Student student){
System.out.println(new Student().age);//88
}
}
五.封装
是指隐藏对象的属性和实现细节,仅对外提供公共访问方式
封装好处:
隐藏实现细节,提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则:
将不需要对外提供的内容都隐藏起来。
把属性隐藏,提供公共方法对其访问
六.private关键字
1通过对象直接访问成员变量是不被允许的,这样会导致一些未知的错误,所以在日常使用时,我们将成员变量通常设置成private权限,这样就不能在成员变量所在类外去通过对象直接调用成员变量,我们通过一个成员变量建立两个类来对成员变
2是一个权限修饰符
3可以修饰成员变量和成员方法
4被其修饰的成员只能在本类中被访问
public class Student {
private String name;
int age;
public void show(){
System.out.println(age);
}
public void setAge(int nianLing){
age=nianLing;
}
public int getAge(int age){
return age;
}
}
public class MyTest {
public static void main(String[] args) {
Student student=new Student();
//student.name="里斯";//报错,private只能访问本类
student.age=19;
student.show();//19
student.setAge(22);
student.show();//22
student.getAge(44);//44
}
}
四种权限修饰符
本类 本包 子类 外包
public 可 可 可 可
protected 可 可 可
(default) 可 可
private 可
七.this关键字
1.引入this的原因
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么
会导致一个问题:就是局部变量隐藏了成员变量的问题
变量访问就近原则:当成员变量与局部变量重名,先在局部范围类使用,找到即使用;
否则去成员范围找,找到就使用
2.特点:
它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
局部变量和成员变量重名时,打印的是默认值
package org.westos.demo3;
public class MyTest {
public static void main(String[] args) {
Student student=new Student();
student.setName(student,"李四");
student.setAge(student,19);
String name = student.getName();
int age = student.getAge();
System.out.println(name);//null
System.out.println(age);//0
}
}
class Student{
private String name;
private int age;
public void setName(Student student,String name){
name=name;
}
public String getName(){
return name;
}
public void setAge(Student student,int age){
age=age;
}
public int getAge(){
return age;
}
}
可以采用创建对象调用方法来解决
可以将对象换为this
package org.westos.demo4;
public class MyTest {
public static void main(String[] args) {
Student student=new Student();
student.setName(student,"李四");
student.setAge(student,19);
String name = student.getName();
int age = student.getAge();
System.out.println(name);//李四
System.out.println(age);//19
}
}
class Student{
private String name;
private int age;
public void setName(Student student,String name){
student.name=name;
}
public String getName(){
return name;
}
public void setAge(Student student,int age){
student.age=age;
}
public int getAge(){
return age;
}
}
package org.westos.demo4;
public class MyTest {
public static void main(String[] args) {
Student student=new Student();
student.setName("李四");
student.setAge(19);
String name = student.getName();
int age = student.getAge();
System.out.println(name);//李四
System.out.println(age);//19
}
}
class Student{
private String name;
private int 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 age;
}
}
总结:
1.Java中基本数据类型是值传递,引用数据类型是引用传递
2.面向对象三大特征:
1)封装:Java中的类封装了成员变量的属性和成员方法的功能
2)继承:子类对父类的继承
(1).在子类继承父类的时候,子类必须调用父类的构造函数。
(2).如果父类有默认构造函数,子类实例化时自动调用,但如果父类没有默认构造函数,即无形参构造函数,子类构造函数必须通过super调用父类的构造函数。
(3).还有在java的继承当中子类是不可以继承父类的构造函数只能调用,这是肯定的。
3.四种权限修饰符:
本类 本包 子类 外包
public 可 可 可 可
protected 可 可 可
(default) 可 可
private 可
4.this关键字:
使用this代表当前类的调用方法的对象