pojo_Person
package com.oop.pojo;
/**
* 包的概念
* 1. 关键词: package
* 2. 用来管理各种源文件,即.java文件
* 如: 所有的实体类,一般都放在com.公司名.项目名.模块名.实体
* reg: com.yc.oop.mgr.pojo(vo ,entity)
* 所有的工具类,一般都放在com.公司名.项目名.模块名.工具
* reg: com.yc.oop.mgr.utils
* 所有的控制类:
* reg: com.yc.oop.mgr.controller
* 所有的服务类:
* reg: com.yc.oop.mgr.service
*
*/
public class Person {
// 成员变量: 这类事物的共同特征,即状态数据,一堆不同类型的变量。 也可以属性/全局变量
String name;
int age;
char gender;
//成员方法: 这类事物的共同行为,可以在这里直接操作成员变量
public void eat(String food){
System.out.println("吃的食物是"+food);
}
public void play(String game){
System.out.println(name+"玩的游戏是"+game);
}
public void work(){
System.out.println(name+"正在工作");
}
//可变长参数: 数据类型...变量名, 注意:该变量是数组。 可变长参数只能放在最后面
public long calculate(int ... a ){
long sum = 0;
// for (int i = 0; i < a.length; i++){
// sum += a[i];
// }
for (int i : a) {
sum += i;
}
return sum;
}
}
pojo_PersonTest
package com.oop.pojo;
import com.oop.pojo.Person;
/**
* 成员的访问:
* 通过引用变量和点来访问
*/
public class PersonTest {
public static void main(String[] args) {
//创建Person类型的一个对象
Person p1 = new Person();
//注意:在没赋值之前,成员变量都是有默认值的。
System.out.println(p1.name); //引用类型的默认值null
System.out.println(p1.age); //byte,short,int,long的默认值是0
System.out.println(p1.gender); //char的默认值lu0000
// 给对象的成员变量赋值
p1.name = "micheal";
p1.age = 18;
p1.gender = '男';
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.gender);
//上述是成员变量的访问,也可以使用该方法访问成员方法
p1.eat("苹果");
p1.play( "王者荣耀");
p1.work();
long sum = p1.calculate( 3,4,5,6,7);
System.out.println(sum);
}
}
pojo_PersonTest2
package com.oop.pojo;
/**
* null和nullPointerException
* null:
* 1. 引用类型的默认值。 表示引用变量里的地址被清空,即无对象的地址信息
* String str = null;
* Person p = null;
* nullPointerException:
* 1. 空指针异常: 运行时发生的
* 2. 变量里面没有地址信息,却使用变量来访问对象的成员。就会发生该异常
*/
public class PersonTest2 {
public static void main(String[] args) {
String str = "Hello World";
System.out.println(str.length());
str = null; //清空地址信息
System.out.println(str.length()); //空指针异常,没有地址指向对象,确访问了对象的成员
Person person = new Person();
System.out.println(person.name);//null
person.name = null;
System.out.println(person.name.length()); //空指针异常
}
}
pojo_Computer
package com.oop.pojo;
/**
* 共同特征:
* 品牌:String
* 型号:String
* 颜色:String
* 显示器尺寸:String
*
* 共同行为:
* open()
* close()
* inserusb(String usb)
*
*/
public class Computer {
String brand;
String model;
String color;
String size;
public void open( ){
System.out.println("打开电脑");
}
public void close( ){
System.out.println("关闭电脑");
}
public void insertUsb(String usb){
System.out.println("插入"+usb);
}
}
pojo_ComputerTest
package com.oop.pojo;
/**
* 包的概念(续)
* 1. 在一个类A中,如果想要使用别的类B,并且类B不和类A同包,那么就需要
* import,导入操作; 将其引入到该类中,才能使用类B中的方法
* 2. 类的名字
* 类名: 类的短名
* 类全名: 从最外层的包开始写的名字,比如Computer这个类
* Computer就是短名,简称类名
* 全名: com.oop.pojo.Computer
*/
public class ComputerTest {
public static void main(String[] args) {
/*
创建Computer对象 语法:new 类名(); 该过程称为实例化
引用变量:
引用类型声明的变量,称为引用变量,简称引用。 因为里面存储不是对象,储存的是对象的内存地址
引用变量,说的是可以通过自己存存的地址找到那个对象,替代了c语言里面的指针
*/
Computer c1 = new Computer();
Person p1 = new Person();
Computer c2 = new Computer();
Person p2 = new Person();
}
}
pojo_Person2
package com.oop.pojo;
/**
* 定义一个Person2类型
* 构造器的相关知识点:
* 1. 类体中,程序员没有提供任何构造器时候,系统已经提供了无参数的构造器
* public 类名(){}
* 2. 程序员一旦提供构造器,系统就不再提供那个无参构造器
* 3. 构造器也是一个方法,但是没有返回值类型这个位置,名字与类名一致
* 4. 构造器不能使用static修饰
* 5. 构造器可以重载,只需要形参列表不一样就可以、
* 6. 构造器的作用就是给成员变量初始化
*/
public class Person2 {
String name;
int age;
char gender;
//无参构造器
public Person2() {
System.out.println("无参数的构造器");
}
//全参构造器
public Person2(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
System.out.println("全参数的构造器");
}
public Person2(String name, char gender){
this.name = name;
this.gender = gender;
this.age = 18; //明确赋值
System.out.println("两参数的构造器");
}
public void showInfo() {
System.out.println("name"+name);
System.out.println("age"+age);
System.out.println("gender"+gender);
}
}
pojo_PersonTest2
package com.oop.pojo;
/**
* 构造器的调用:
* 1. 使用new关键字
* new 构造方法(有参传参)
*/
public class Person2Test {
public static void main(String[] args) {
//调用Person2的无参构造器实例化和初始化一个对象
Person2 p1 = new Person2();
p1.showInfo(); //因为无参构造器中没有初始化操作,因此都是默认值
//调用全参构造器实例化和初始化一个对象 ctrl+p: 用于查看重载的方法参数
Person2 p2 = new Person2("小明",20,'男');
p2.showInfo();
//调用两个参数的构造器,实例化和初始化一个对象
Person2 p3 = new Person2("小红",'女');
p3.showInfo();
}
}
pojo_Cat
package com.oop.pojo;
/**
* this.关键字
* this. 是隐藏在成员方法里的成员变量前面的关键字
*/
public class Cat {
String name;
String brand;
String color;
public void setInfo( String a, String b, String c){
//成员变量前,隐藏了this. 可以写也可以省略
name = a;
this.brand = b;
color = c;
}
public void setInformastion(String name, String brand, String color){
//当形式参数的名字和成员变量的名字相同时,如果想要在这个作用域内
//表示成员变量,需要使用this.不能省略
this.name = name;
this.brand = brand;
this.color = color;
}
public void showInfo(){
System.out.println("name" + name + "brand" + brand +"color"+color);
}
public static void main(String[] args) {
//创建Cat对象
Cat c1 = new Cat();
//调用setInfo给c1对象赋值
c1.setInfo("coke","英短","白色");
//调用showInfo方法 27行
c1.showInfo();
//调用setInformastion修改对c1对象赋值
c1.setInformastion( "code","逻辑","黑色");
c1.showInfo();
}
}
pojo_Person3
package com.oop.pojo;
/**
* 构造器的调用(续):
* 1. 在构造器可以使用this(有参传参)的方式调用本类中的其他构造器
* 2. this()只能写在构造器的第一行
*/
public class Person3 {
String name;
int age;
char gender;
public Person3(){
this.name = "";
this.age = -1;
this.gender = 'f';
}
public Person3(String name){
this.name = name;
}
public Person3(String name, int age){
//调用了本类中的一个参数构造器
this(name);
this.age = age;
}
public Person3( String name, int age, char gender) {
//调用了本类中的两个参数构造器
this(name, age);
this.gender = gender;
}
public void showInfo(){
System.out.println("name"+name);
System.out.println("age"+age);
System.out.println("gender"+gender);
}
public static void main(String[] args) {
Person3 p1 = new Person3("小黑", 18);
p1.showInfo();
//调用全参构造器
Person3 p2 = new Person3( "小明", 18, '男');
p2.showInfo();
}
}
exercise_Exercise
package com.oop.exercise;
/*
要求:
1.提供一个全参数的构造器
2.提供一个用户名和密码的构造器。默认的邮箱地址是:用户名@yc.com
3.提供一个showInfo方法
3.测试1:调用全参构造器,显示信息
测试2:调用两个参数构造器,显示信息
*/
public class Exercise {
String name;
String password;
String email;
public Exercise(String name, String password, String email) {
this.name = name;
this.password = password;
this.email = email;
}
public Exercise(String name, String password) {
this.name =name;
this.password = password;
this.email = name+ "@yc.com" ;
}
public void showInfo() {
System.out.println("name" + name);
System.out.println("password" + password);
System.out.println("email" + email);
}
public static void main(String[] args) {
// 测试1: 调用全参构造器
Exercise user1 = new Exercise("A", "123", "alice@example.com");
user1.showInfo();
// 测试2: 调用两个参数构造器
Exercise user2 = new Exercise("B", "456");
user2.showInfo();
}
}
exercise_Interview
package com.oop.exercise;
import java.util.Arrays;
public class Interview {
public static void main(String[] args) {
int a = 5;
char[] chs = {'m','n','p'};
char[] rs = m(a,chs);
System.out.println(a); //5
System.out.println(Arrays.toString(rs)); //[m, x, p]
System.out.println(Arrays.toString(chs)); //[m, x, p]
}
public static char[] m(int a, char[] chs) {
a = 10;
chs[1] = 'x';
return chs;
}
}
contain_PersonTest
package com.oop.contain;
import com.oop.pojo.Person2;
/**
* JVM内存管理机制:
*
*/
public class PersonTest {
public static void main(String[] args) {
int a = 18;
char b = 'a';
long c = add(a,b);
System.out.println("c="+c);
Person2 p = new Person2( "小明", 18, '女');
p.showInfo();
}
public static long add(int a, int b) {
int x = a ;
int y = b ;
int z = x + y ;
return z ;
}
}
codeblock_blockDemo
package com.oop.codeblock;
/**
* 代码块的学习:
* 1. 动态代码块(构造代码块)
* 语法:
* {
* 代码片段
* }
* 位置:与构造器并列,都是在类体中
* 特点: 构造器执行一次,动态代码块就执行一次,并先于构造器执行。
* 作用:一般用于统计一个类型创建了多少个对象,或者提前给成员变量赋值
*
* 2.静态代码块(静态块)
* 语法:
* static{
* 代码片段
* }
* 位置: 与构造器并列,都是在类体中
* 特点: 只执行一次,在类加载器将该类的信息家在到内存时,执行的
* 作用: 一般用于加载静态资源到内存中,比如图片,音乐,视频等
*
*/
public class BlockDemo {
public static void main(String[] args) {
//调用无参构造器实例化对象
BlockDemo bd = new BlockDemo();
System.out.println(bd);
// 调用有参构造器实例化对象
BlockDemo bd2 = new BlockDemo(10,20);
System.out.println(bd2); //默认调用toString()方法
}
int a;
int b;
static{
System.out.println("静态代码块执行了");
}
{
System.out.println("动态代码块执行了");
}
public BlockDemo() {
System.out.println("无参构造器执行了");
}
public BlockDemo(int a, int b) {
System.out.println("有参构造器执行了");
this.a = a;
this.b = b;
}
/*
String toString(): 将对象的成员信息便于一串字符串,并返回
该方法,在将引用变量放在输出语句中时,会默认调用
*/
public String toString(){
return "a = "+a+", b = "+b;
}
}