Day 15 类

最新推荐文章于 2024-10-06 20:16:20 发布

墨明0414

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量109

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/liutao0414/article/details/126573617

版权

JavaSE 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

包的概念

实际开发中分包的概念: 包都是用的是多级包公司域名反写,中间.隔开

代码分层不同的包下放的不同代码

业务层代码 service-----------逻辑判断

数据数据访问层 dao(data access object :数据访问对象)

放一些实体类(描述事物的一些属性)pojo/entity/domain

测试类的代码: main 方法测试 ----> 包名 test

以后前后端交互:包名 controller/web :后端接口的具体地址

权限修饰符的范围

private:私有的
默认修饰符 :没有任何修饰
protected 受保护的
public :公共的公开的

	成员方法	同一个包下	不同包下的子类中	不同包下的无关类中
private	√
默认修饰符	√	√
protected	√	√	√
public	√	√	√	√

权限修饰符的范围: private 最小,其次默认修饰符,然后protected受保护的,最大为public

形式参数 --返回值问题

具体类

如果是具体类,调用方法的时候,实际参数需要这个类的具体对象

class Student{
public void study(){
System.out.println("学习JavaEE之JavaSE基础");
}
}
class StudentDemo{
public void method(Student student){//形式参数一个引用类型:具体类,调用该
方法,实际参数需要一个学生对象
student.study() ;
}
}
//测试类中测试
//调用StudentDemo类的method方法
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//调用该方法,实际参数需要一个学生对象
Student s = new Student() ;
sd.method(s); //实际参数s

抽象类

如果是抽象类,调用方法,实际参数需要传递抽象类的子类对象

abstract class Person{//人类
public abstract void work(); //工作
}
class PersonDemo{
//成员方法
public void show(Person p){//形式参数是一个抽象类,抽象类不能实例化,需要
//new 它的子类对象 抽象类多态
p.work() ;
}
}
//必须提供子类
//只能现在提供抽象类的具体的子类
class Worker extends Person{
@Override
public void work() {
System.out.println("爱生活,爱工作,爱高圆圆");
}
}
//测试类中测试
PersonDemo pd = new PersonDemo() ;
//创建Person对象
//Person p = new Person(); 抽象类不能实例化
// pd.show(p);
//抽象类多态
Person p = new Worker() ;
pd.show(p);
System.out.println("-----------------------------------------");
//匿名对象
pd.show(new Worker());

接口

如果是接口,调用方法,实际参数需要传递接口的子实现类对象

interface Love{
void love() ;
}
class LoveDemo{
public void function(Love lo){ //方法形式参数是一个接口类型,接口new不了
lo.love();
}
}
//需要提供具体的子实现类
class LoveImpl implements Love{
@Override
public void love() {
System.out.println("love loveImpl...");
}
}
//测试类中测试
//调用LoveDemo类的中的function方法
//创建LoveDemo类对象
LoveDemo ld = new LoveDemo() ;
/创建Love对象
//Love love = new Love() ;//接口不能实例化,肯定需要接口的子实现类
//ld.function(love);
//接口多态的方式:接口名 对象名 = new 具体的子实现类名() ;
Love love = new LoveImpl() ; 
ld.function(love);
//方式2:
ld.function(new LoveImpl()) ;

内部类（了解）–属于设计层面

常用类之Object–看jdk的api

内部类

成员内部类

class Outer{
class Inner{ //成员内部类
}
}

外部类如何直接访问外部类的成员内部类的成员方法?

class Outer{
private int num = 100 ;
class Inner{
//这个是非静态的成员内部类:才能使用外部类名.内部类名 对象名 =
外部类对象.内部类对象;
public void show(){
//成员内部类可以直接访问外部类成员,包括私有
System.out.println(num) ;
}
}
//在外部类的成员方法中访问show
public void method(){
//创建成员内部类对象
Inner inner = new Inner();
inner.show() ;
}
}
//测试类中测试直接访问show(
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();
oi.show() ;

静态成员内部类

成员内部类可以被static修饰

成员被static修饰:这个成员内部类的中的所有的方法:静态的还是非静态的,访问外部类的成员必须只能拿访问静态的东西

静态的成员内部类:外部类直接访问静态内部类的成员,
将静态的成员内部类看成是外部类的静态成员
外部类名.内部类名对象名 = new 外部类名.内部类名();

//外部类
class Outer3{
private int num = 20 ;
private static int num2 = 50 ;
//静态的成员内部类
static class Inner3{
//非静态的方法
public void show(){
//System.out.println(num);
System.out.println(num2) ;
}
//静态的方法
public static void show2(){
//System.out.println(num);
System.out.println(num2);
}
}    
}

//测试类
public class InnerClassDemo3 {
public static void main(String[] args) {
//要访问静态的成员内部类中的成员方法以及静态方法?
//外部类名.内部类名 对象名 = 外部类对象.内部类对象; //这个格式针对
成员内部类非静态
// Outer3.Inner3 oi = new Outer3().new Inner3() ;
//外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer3.Inner3 oi = new Outer3.Inner3();
oi.show(); //show() 静态成员内部类的非静态的方法: 必须对象来访问
oi.show2() ;//show2():静态方法:不推荐 对象名访问访问
//静态东西:使用类名访问
System.out.println("-------------------------------------------") ;
//Inner3类看成是Outer3静态成员,show2()在Inner3也是静态的方法
Outer3.Inner3.show2() ;
}
}

成员内部类面试题

**
* 看程序,补全代码 控制台输出,30,20,10
*
* 内部类和外部类就没有继承关系
*/
class Outer4{
int num = 10 ;
//成员内部类
class Innter4{
int num = 20 ;
//成员内部类的成员方法
public void show(){
int num = 30 ;
//补全代码
System.out.println(num);//遵循就近
System.out.println(this.num); //this:代表当前类对象的地址值引用Inner4这个类的方法
  // System.out.println(new Outer4().num); //new Outer4().num :外部
类对象访问
System.out.println(Outer4.this.num) ; //外部类名.this.变量名: 外
部类的this限定
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
Outer4.Innter4 oi = new Outer4().new Innter4() ;
oi.show();
}
}

局部内部类

局部内部类:在外部类的局部位置,方法定义中
*
* 特点:
* 不管是局部内部类/成员内部类: 里面的成员都可以直接访问外部类的成员包
括私有
*
* 如果通过外部类直接访问局部内部类的成员?
* 在局部位置上,创建了局部内部类的对象,对象名调用成员方法
*

面试题:

* jdk版本7的版本,局部内部类访问的外部类的成员方法的局部变量,这个局
部变量有什么特点?为什么?
* jdk7的版以及以前:int num = 20 ; 立即报错:必须被final修饰!
* jdk8已经优化了,通过反编译查看, num已经被final修饰符
*
* 为什么?
* 因为局部变量的生命周期,随着方法的调用而存在,随着方法调用结束而
消失,下面这个代码show(),调用完毕,num应该就被是释放了
*
* 但是,show方法里面创建的局部内部类对象,对象里面的成员方法在间接
的使用局部变量,此时不能让num立即释放,必须为final修饰符
* 最终的,无法更改的,是一个常量!

/外部类
class Outer{
private int x = 100 ;
//外部类的成员方法
public void show(){
int num = 20 ; //隐藏了final修饰符
//局部内部类
class Inner{
//成员方法
public void method(){
System.out.println(x);//局部内部类的成员在访问外部类的成员
System.out.println(num) ; //此时这里面需要访问的外部类的局部
变量num
}
}
//创建局部内部类对象
Inner inner = new Inner() ;
inner.method();
}
}
//测试类
public class InnerClassDemo {
public static void main(String[] args) {
//就创建外部类的对象
Outer outer = new Outer() ;
outer.show();
}
}

匿名内部类

匿名内部类是局部内部类的一种简化格式(重点)

匿名内部类:就是没有名字的类
* 格式
*
* 抽象类或者接口的匿名内部类
* new 类名或者是接口名(){ //类:一般都是抽象类 ,具体 * 类也可也,但是不推荐
*
* 重写方法() {
* ...
* }
* };
* 场景范围:就是在方法的形式参数以及返回值是抽象类或者接口的情况下,是一种简
化格式
* 匿名内部类的本质:
* 就是继承该类(抽象类)或者实现了给接口的子类对象;


interface Love{
void show() ;
void show2() ;
}
/*
class LoveImpl implements Love{ //类名 LoveImpl
@Override
public void show() {
}
@Override
public void show2() {
}
}
*/
//外部类
class Outer2{
public void method(){
//没有使用匿名内部类之前
/* class Inner2{
public void show(){
System.out.println("show Inner...");
}
public void show2(){
System.out.println("show2 Inner... ");
}
}
//创建Inner对象
Inner2 inner = new Inner2() ;
inner.show();
inner.show2() ;*/
/*
new 类名或者是接口名(){
* 重写方法() {
...
}
};
*/
//匿名内部类格式:简化书写格式
/* new Love(){
@Override
public void show() {
System.out.println("show Love");
}
@Override
public void show2() {
System.out.println("show2 Love");
}
}.show();
new Love(){
@Override
public void show() {
System.out.println("show Love");
}
@Override
public void show2() {
System.out.println("show2 Love");
}
}.show2();*/
//上面这个格式在访问方法上面比较麻烦
//优化:
//给匿名内部类 new 类名或者接口名(){...重写方法} 起一个对象名字
Love l = new Love(){
@Override
public void show() {
System.out.println("show Love");
}
@Override
public void show2() {
System.out.println("show2 Love");
}
} ;
l.show();
l.show2();
}
}
//测试类
public class NoClassDemo {
public static void main(String[] args) {
Outer2 outer2 = new Outer2() ;
outer2.method();
}
}

匿名内部类在开发中的使用 (形式参数是一个抽象类）

/**
* 匿名内部类在开发情况的使用
*
* 方法的形式参数如果是抽象类的情况,调用该方法,实际参数需要传递当前抽象类的
子类对象
*
* 匿名内部类的本质:
* 代表继承了 该类(抽象类)或者实现类该接口的子类对象
* new 抽象类名或者接口名(){
*
* 重写抽象方法...
* } ;
*/
abstract class Person{
public abstract void work() ;//工作
}
class PersonDemo{
public void method(Person p){ //抽象类 作为形式参数,抽象类不能实例化
p.work();
}
}
//定义子类 继承自Person类,重写work
/*class Worker extends Person{
@Override
public void work() {
System.out.println("日日夜夜敲代码...");
}
}*/
//测试类
public class Test {
public static void main(String[] args) {
//调用PersonDemo类的method 方法
/* PersonDemo pd = new PersonDemo() ;
//抽象类多态:
Person p = new Worker() ;
pd.method(p)*/; // ---->p.work();
//方式2:匿名内部类
PersonDemo pd = new PersonDemo() ;
// new 抽象类名或者接口名(){
// *
// * 重写抽象方法...
// * } ;
pd.method(new Person(){
@Override
public void work() {
System.out.println("日日夜夜敲代码");
}
});
}
}

匿名内部类在开发中的使用 (形式参数是一个接口)

/**
* 方法的形式参数如果是一个接口,调用方法,实际参数需要传递该接口子实现类对象
*/
//飞的接口
interface Fly{
void fly() ;
}
class FlyDemo{
public void method(Fly fly){//方法的形式参数是一个接口,调用方法,需要接口
的子实现类对象
fly.fly();
}
}
//定义一个子实现类 实现Fly接口
class Bird implements Fly{
@Override
public void fly() {
System.out.println("鸟会飞了...");
}
}
//测试列
public class Test2 {
public static void main(String[] args) {
//调用FlyDemo类的method方法
FlyDemo fd = new FlyDemo() ;
//接口多态
Fly fly = new Bird() ;
fd.method(fly); //----->fly.fly();
System.out.println("------------------------------------------");
//直接 匿名内部类
/**
* new 类名或者接口名(){
* 重写方法
* } ;
*/
FlyDemo fd2 = new FlyDemo() ;
fd2.method(new Fly(){
@Override
public void fly() {
System.out.println("会飞了...");
}
});
}
}

匿名内部类,在方法的返回值的用法(返回值是抽象类)

/**
* 返回值问题:
* 如果方法的返回值是抽象类型,方法结束,需要返回抽象类的子类对象
*/
abstract class Person2{
public abstract void work() ;
}
class CodeDemo{
public Person2 show(){
//需要返回抽象类的子类对象
//抽象类多态
/*Person2 p = new Programmer() ;
return p;*/
//使用抽象类的匿名内部类的格式
return new Person2(){
@Override
public void work() {
System.out.println("程序员日日夜夜开发项目");
}
} ;
}
}
//定义一个子类
class Programmer extends Person2{
@Override
public void work() {
System.out.println("程序员不断开发新的项目");
}
}
//测试类
public class Test3 {
public static void main(String[] args) {
//调用CodeDemo的show
/* CodeDemo cd = new CodeDemo() ;
Person2 p = cd.show() ;//---本质:new Programmer() ;
p.work();*/
CodeDemo cd2 = new CodeDemo() ;
Person2 person2 = cd2.show();
person2.work();
}
}

匿名内部类,在方法的返回值的用法(返回值是接口)

/**
* 方法的返回值问题:
* 如果是接口类型,方法结束,必须要返回接口的子实现类对象
*/
//会吼叫的接口
interface CanCry{
void cry() ; //吼叫的方法
}
class CryDemo{
public CanCry funtion(){
//返回接口的子实现类对象
//接口多态
/* CanCry canCry = new Cat();
return canCry ;*/
//接口匿名内部类
return new CanCry() {
@Override
public void cry() {
System.out.println("狗发出汪汪汪的吼叫");
}
} ;
}
}
//定义CanCry接口的子实现类实现cry方法
class Cat implements CanCry{
@Override
public void cry() {
System.out.println("猫发出喵喵的吼叫");
}
}
//测试类
public class Test4 {
public static void main(String[] args) {
//调用CryDemo的function方法
/* CryDemo cd = new CryDemo() ;
CanCry cc = cd.funtion() ; //本质---->new Cat() ;
cc.cry();*/
CryDemo cd2 = new CryDemo() ;
CanCry cc = cd2.funtion() ; //本质--->接口的匿名内部类--->代表任意子
实现类对象
cc.cry();
}
}

常用类

Object类:

重点类所有的类的父类:几乎的成员方法都需要被

任何子类重写 toString()/hashCode()/equals()…

String类（重点类,开发中使用最多的）

String s = new String("hello") ;
String s2 = "hello" ; //常量---常量池中 (推荐这种方式)
转换功能: char[] toCharArray()

byte[] getBytes()

截取

subString(int begin,int end)

包前不包后字符串的其他功能:替换/去除两端空格…

StringBuffer:字符串缓冲区

append(传递任何数据类型) :追加

StringBuffer----String类型

String类型----StringBuffer

Integer :int类型包装类类型:

String–> Integer–>int

Integer.parseInt(String字符串值)—>int

String---->Long–> long

Long.parseLong(String字符串)—long

int–>Integer–>String

Character:char类型的包装类类型:

判断功能:

public static boolean isUpperCase() :是否为大写

public static boolean isLowerCase() :是否为小写

public static boolean isrDigit() :数字字符

java.util.Date:日期类 :重点类型转换

String:文本格式 ------Date格式

应用场景:

网页中日期组件 2022-8-16:String 文本格式------>Date格式 Calendar:日历类/Math:数学运算/Random:随机数生成器

Object类的成员方法和String类重点构造方法总结

Object类里面的toString():建议所有子类重写,直接输出对象名称,看到的一个简明扼要的信息表达式而不是一堆地址值;

Object里面的equals() :建议所有子类重写, 否则,默认比较的引用数据类型的地址值是否一样,重写之后,比较的是成员信息是否相同;

String类构造方法 String(char[] chs) :将字符数组构造成

String String(byte[] bytes):将字节数组构造成String

String类的特点:

一旦被创建,其值不能被更改;

面试题

String s1 = “hello”;

String s2 = new String (“hello”);

他们分别创建了对象，有什么区别呢？

s1: 先在常量池中，是否存在这个常量，如果存在直接返回地址值；否则，开辟新空间地址值，赋值s1

s2:在堆内存中申请空间，然后常量"hello",

还需要在常量池中找到是否存在这个常量，有，就返回地址，重新开辟常量池空间