第三章第二节 面向对象基础
前言
面向对象基础
类与对象的创建
package day01;
/**
* class 类名{
* 成员属性;
* 成员方法;
*
* }
*
* 类必须编写在.java文件中,
* 一个.java文件中, 可以存在N个类, 但是只能存在一个public修饰的类.
* .java文件的文件名称 必须与public修饰的类名 完全一致.
* @author jiajun.lin
*
*/
public class Demo1 {
public static void main(String[] args){
//创建对象的格式:
//类型 对象名 = new 类名();
//类的对象的方法使用
Person p = new Person();
// 给对象属性赋值
//格式: 对象名.属性名 = 值;
p.name = "张三";
p.age = 18;
p.sex = '男';
p.say();
}
}
/**
* 类就像是图纸
* 对象:未来图纸包含的
* @author jiajun.lin
*
*/
//类定义
class Person{
//属性 - 特征
String name;
int age;
char sex;
//方法 - 行为
/**
* void 表示灭有返回值
* 定义方法的格式
* 返回值类型 方法名称(形式参数列表){
* 方法体
* return 返回值;
* }
* 方法的调用格式
* 某对象的某行为
* 对象名.方法名称(实际参数列表);
*/
//类的方法定义
void say() {
System.out.println("自我介绍: 我是"+name+", 我的年龄: "+age+", 我的性别: "+sex);
}
}
方法的补充
package day01;
/**
* class 类名{
* 成员属性;
* 成员方法;
*
* }
*
* 类必须编写在.java文件中,
* 一个.java文件中, 可以存在N个类, 但是只能存在一个public修饰的类.
* .java文件的文件名称 必须与public修饰的类名 完全一致.
* @author jiajun.lin
*
*/
public class Demo1 {
public static void main(String[] args){
//创建对象的格式:
//类型 对象名 = new 类名();
//类的对象的方法使用
Person p = new Person();
// 给对象属性赋值
//格式: 对象名.属性名 = 值;
p.name = "张三";
p.age = 18;
p.sex = '男';
p.say();
//sum 调用方法并传递参数的返回值
int s = p.sum(100, 200);
System.out.println(s);
}
}
/**
* 类就像是图纸
* 对象:未来图纸包含的
* @author jiajun.lin
*
*/
//类定义
class Person{
//属性 - 特征
String name;
int age;
char sex;
//方法 - 行为
/**
* void 表示灭有返回值
* 定义方法的格式
* 返回值类型 方法名称(形式参数列表){
* 方法体
* return 返回值;
* }
* 方法的调用格式
* 某对象的某行为
* 对象名.方法名称(实际参数列表);
*/
//类的方法定义
void say() {
System.out.println("自我介绍: 我是"+name+", 我的年龄: "+age+", 我的性别: "+sex);
}
//方法的补充
int sum(int x,int y) {
int z = x+y;
return z;
}
/*
void xxx() {
if(true) {
return;//return表示我们方法执行完成后产生的结果
}
System.out.println("哈哈");
}
*/
}
对象创建补充
package day01;
public class Demo1 {
public static void main(String[] args){
//两本书b1,b2
Book b1 = new Book();
Book b2 = new Book();
b1.name = "金苹果";
b1.info = "讲述了果农种植金色苹果的辛勤路程. ";
b2.say();
}
}
class Book{
String name;
String info;
void say() {
System.out.println("书名: "+name+" , 简介: "+info);
}
}
package day01;
public class Demo1 {
public static void main(String[] args){
//两本书b1,b2
Book b1 = new Book();
Book b2 = new Book();
b1.name = "金苹果";
b1.info = "讲述了果农种植金色苹果的辛勤路程. ";
b2.name = "银苹果";
b2.info = "讲述了果农终止银色苹果的辛勤路程. ";
//两个对象的情况不同, 输出的结果也不同
b1.say();
b2.say();
}
}
class Book{
String name;
String info;
void say() {
System.out.println("书名: "+name+" , 简介: "+info);
}
}
对象创建内存01
package day01;
/**
* 对象创建的内存细节
* @author jiajun.lin
*
*/
public class Demo1 {
public static void main(String[] args){
Book b1 = new Book();
b1.name = "金苹果";
b1.info = "讲述了果农终止金色苹果的辛勤路程";
b1.say();
//b1,b2就是个名称,b1和b2都是同个,两个名字指向同一个内存
//结果两个都改了
Book b2 = b1;//复制?其实不是
b2.name = "嘿嘿嘿";
//两个结果都输出,本来是想要只输出b1的
b1.say();
}
}
class Book{
String name;
String info;
void say() {
System.out.println("书名: "+name+" , 简介: "+info);
}
}
重点是:栈和堆
对象创建内存02
JAVA中一个线程就有一个栈
很多事情要去做,可以分为多个
栈:先进后出的方式
创建空间和释放空间的速度非常快
堆:引用数据类型的对象,占用空间是不固定的
package day01;
public class Demo1 {
public static void main(String[] args){
Book b1 = new Book();
b1.name = "金苹果";
b1.info = "讲述了果农终止金色苹果的辛勤路程";
b1.say();
Book b2 = b1;
b2.name = "嘿嘿嘿";
b1.say();
}
}
class Book{
String name;
String info;
void say() {
System.out.println("书名: "+name+" , 简介: "+info);
}
}
1.方法区
2.栈内存:对象的名称以及基本数据类型的值
一开始Book b1 为null
3.堆内存:new Book()得到0x1234内存地址
后 Book b1 为0x1234
Book b1 = new Book();
b1.name = “金苹果”;
b1.info = “讲述了果农种植金色苹果的辛勤路程.”;
Book b2 = b1;
b2.name = “嘿嘿嘿”;
b1.say();
}表示走完了,就要释放->b2->b1
GC的垃圾回收
对象创建内存03
package day01;
/**
* 对象创建的内存细节
* @author jiajun.lin
*
*/
public class Demo1 {
public static void main(String[] args){
Book b1 = new Book();
b1.name = "金苹果";
b1.info = "讲述了果农终止金色苹果的辛勤路程";
b1.say();
Book b2 = new Book();
b2.name = "银苹果";
b2.info = "讲述了果农辛勤种植银苹果的过程. ";
b2 = b1;
b2.name = "铜苹果";
b1.say();
}
}
class Book{
String name;
String info;
void say() {
System.out.println("书名: "+name+" , 简介: "+info);
}
}
描述
GC垃圾回收就是不存在对象引用
构造方法
构造器:至少一个构造方法,没有明确编写会自动生成一个
Person p = new Person();
package day01;
public class Demo2 {
public static void main(String[] args) {
System.out.println("1");
Person2 p1 = new Person2();
p1.name = "张三";
p1.age = 18;
p1.say();
}
}
class Person2{
//构造方法不存在返回值类型的声明,方法名称与类名完全一致
//创建对象时候就调用了该方法
Person2(){
System.out.println("构造方法执行了");
}
String name;
int age;
void say() {
System.out.println("自我介绍, 我是: "+name+" , 我的年龄:"+age);
}
}
项目场景:链接数据仓库
创建对象,存储
Person2(String n){}是一个有参数的构造方法,
而Person2 p1 = new Person2();相当于调用了一个有参数的构造方法;
这意味着无法自动生成一个无参数且无任何代码的构造方法,必须传递一个参数
package day01;
public class Demo2 {
public static void main(String[] args) {
System.out.println("1");
Person2 p1 = new Person2("haha");
System.out.println("2");
p1.name = "张三";
p1.age = 18;
p1.say();
}
}
class Person2{
Person2(String n){}
String name;
int age;
void say() {
System.out.println("自我介绍, 我是: "+name+" , 我的年龄:"+age);
}
}
传入该参数的意义是什么?
可能我们想给对象传递一些值
package day01;
public class Demo2 {
public static void main(String[] args) {
//System.out.println("1");
Person2 p1 = new Person2("张三");
//System.out.println("2");
//p1.name = "张三";
p1.age = 18;
p1.say();
}
}
class Person2{
Person2(String n){
name = n;
}
String name;
int age;
void say() {
System.out.println("自我介绍, 我是: "+name+" , 我的年龄:"+age);
}
}
不要依赖自动生成的构造方法
方法的重载
啥是方法的重载?
-
- 方法名称相同
- 2.参数列表长度 或 参数列表的类型 或 参数顺序不同
-
- 注意: 与返回值类型无关
不同参数的相同方法
方法名称不同
package day01;
public class Demo2 {
public static void main(String[] args) {
Math m = new Math();
int num = m.sum(100, 500);
System.out.println(num);
double num2 = m.sum2(10.5, 20.6);
System.out.println(num2);
}
}
// 命名规范 见名知意
class Math{
//这个方法用于计算int类型的
int sum(int x,int y) {
int z = x+y;
return z;
}
double sum2(double x,double y) {
double z = x+y;
return z;
}
}
方法名称相同
package day01;
public class Demo2 {
public static void main(String[] args) {
Math m = new Math();
int num = m.sum(100, 500);
System.out.println(num);
double num2 = m.sum(10.5, 20.6);
System.out.println(num2);
}
}
// 命名规范 见名知意
class Math{
/**
*
* 一个类中定义的方法, 是允许重载 (相同的方法名称)
*
* 1. 方法名称相同
* 2.参数列表长度 或 参数列表的类型 或 (参数类型顺序不同)
*
* 注意: 与返回值类型无关
*/
//这个方法用于计算int类型的
int sum(int x,int y) {
int z = x+y;
return z;
}
double sum(double x,double y) {
double z = x+y;
return z;
}
}
package day01;
public class Demo2 {
public static void main(String[] args) {
Math m = new Math();
int num = m.sum(100, 500);
System.out.println(num);
double num2 = m.sum(10.5, 20.6);
System.out.println(num2);
}
}
// 命名规范 见名知意
class Math{
/**
*
* 一个类中定义的方法, 是允许重载 (相同的方法名称)
*
* 1. 方法名称相同
* 2.参数列表长度 或 参数列表的类型 或 (参数类型顺序不同)
*
* 注意: 与返回值类型无关
*/
//这个方法用于计算int类型的
int sum(int x,int y) {
int z = x+y;
return z;
}
double sum(double x,double y) {
double z = x+y;
return z;
}
//参数类型顺序不同
double sum(int x , double y) {
double z = x+y;
return z;
}
double sum(double y, int x) {
double z = x+y;
return z;
}
}
方法重载:是根据传入的参数类型去调用方法
构造方法重载
package day01;
/**
* 构造方法的重载:
* 方法名称相同,参数的个数,类型不同
* @author jiajun.lin
*
*/
public class Demo3 {
public static void main(String[] args) {
Person3 p = new Person3("张三",18);
p.say();
Person3 p2 = new Person3("李四");
p2.say();
}
}
class Person3{
Person3(String name2,int age2){
name =name2;
age = age2;
}
//构造方法重载
Person3(String name2){
name = name2;
}
String name;
int age;
void say() {
System.out.println("自我介绍: 姓名: "+name+", 年龄: "+age);
}
}
匿名对象
package day01;
public class Demo3 {
/**
* 匿名: 没有名字,没有对象名,没有引用名
* 本来程序的栈内存有名字,而堆中没有名字
* 现在匿名就是栈内存没有名字,没有给对象取名字,就使用了一次
* 匿名对象:num = new Math().sum(100, 200);
* @param args
*/
public static void main(String[] args) {
//
//Math2 m = new Math2();
//int num = m.sum(100, 200);
//相当于
int num = new Math2().sum(100, 200);
System.out.println(num);
}
}
class Math2{
int sum(int x,int y) {
return x+y;
}
}
匿名对象2
三个new,在堆内存中开辟了三个匿名对象
package day01;
public class Demo4 {
/**
* 如果一个对象准备使用2次或以上,就一定要给对象创建对象名
* @param args
*/
public static void main(String[] args) {
new Person5().name = "张三";
new Person5().age = 18;
new Person5().say();
}
}
class Person5{
String name;
int age;
void say() {
System.out.println("自我介绍: 姓名: "+name+" ,年龄: "+age);
}
}
编程规范
码出高效
alibaba Java 1.4.0
国内唯一参与java规则制定的公司
阿里巴巴编程规约插件