类和对象

最新推荐文章于 2023-05-03 22:23:19 发布

chaunceny

最新推荐文章于 2023-05-03 22:23:19 发布

阅读量211

点赞数

分类专栏： core java 文章标签：对象异常封装继承多态

本文链接：https://blog.csdn.net/chaunceny/article/details/79921202

版权

core java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

类和对象

1. 什么是面向对象？

1.面向对象是一种编程思想

2.面向对象是一种思考问题的方式

2. 面向对象的基础？

类对象属性方法

3. 什么是类？

1.类：分类，类别

2.通过分类：饿哦们可以区分不同的事物种类，在日常生活中我们就是这么分类的

总结：所以说：类是一组具有相同特征【属性】和行为【方法】的事物的集合

4.什么是对象？

生活中的对象：一个具体的事物，用于自己的特征和行为【看的见摸得着的事物】

5. 对象和类的关系

1.类表示共性的产物

2.对象是共性常务具体化的一个实例【具有自己的特征和行为】

总结：类是对象的类型对象是类的实例

6. 程序中如何描述类对象属性方法

类是一组具有相同特征【属性】行为【方法】的事物的集合

1.创建类 public class 类名

2.在类中定义共有的属性

3.在类中定义共有的方法

4.实例化类创建对象类名对象名=new 类名（）；

5.调用类的属性对象名.属性

6.调用类的属方法对象名.方法（）；

7.new关键字的作用

1.new关键字表示创建/实例化一个对象

2.new关键字表示申请内存空间

注意：如果使用一个没有申请内存空间的对象，会报空指针(java.lang.NullPointerException)

8.如何建立面向对象的思维方式

1.先整体后局部定义类

2.先抽象再具体定义属性实例化之后赋值

3.能做什么具体怎么做定义方法在实现（重写）方法

9.一些基本的数据类型的默认值

数据类型默认值

byte short int long 0

float double 0.0

boolean false

String null

10.全局变量有默认值局部变量没有默认值

局部变量优先于全局变量

11.返回值的方法

void 代表无返回值

return 将结果返回给方法/跳出方法

注意：返回值类型与返回类型要一致

12.方法的调用

同类方法调用方法名([参数]);

不同类对象名.方法名（[参数]）；

13.方法的参数注意

方法的形参与实参个数一致类型一致顺序一致

14.基本数据类型传递引用数据类型传递

都是给的副本

但是引用类型指向的是地址在地址中修改其值会发生改变

15.构造函数

1.每个类都有一个无参构造默认的

2.作用：方便快捷的创建对象实例

构造函数的快捷键 shfit+alt+s+o

格式：public 类名（【参数】）{}

16.方法的重载

方法的重载：同类中相同的方法名相同列表不同与修饰符返回值无关

作用：给用户提供了多种选择性

面向对象三大特征

1. 封装

1.属性私有化

2.对外提供两个方法 get[取值]/set[存执]

3.在set方法里面控制添加数据的判断

作用：确保数据安全，避免误操作

快捷键：shift+alt+s+r

2. static 静态

作用：不用实例化调用，变量在内存中只有一次拷贝，节约资源

用法：static修饰变量方法块

注意：静态的属性和方法可以直接通过类名访问

静态变量：

静态的变量是所有对象共有的，其中一个对象将他的值改变了，其他的对象得得到的就是改变之后的值

在内存中只有一次拷贝

普通变量【实例变量】

实例变量则属于对象私有，某一个对象将其值改变，不影响其他对象

方法：

普通方法【实例方法】

实例方法不能声明静态变量。

静态方法：

静态方法可以调用静态属性，静态方法不能使用this

实例方法可以调用实例方法，实例属性，静态属性，静态方法

块：

作为初始化只被执行一次，一般用于对静态属性的初始化

3. 如何实现继承

1.父类抽取共性

2.子类通过extends关键字继承

3.使用super关键字可以调用父类的构造函数/方法/属性

继承下的构造函数

实例化子类时默认调用父类的无参构造

无参构造不存在时可以显示调用父类的其他构造

注意：继承具有单根性子类只能有一个直接的父类

构造函数不能继承只能调用。

继承的好处：

降低代码的冗余提高代码的重用

4. 方法的重写

重写的是什么？子类继承父类的方法；

子类根据需求对父类继承的方法进行重新编写【父类的方法无法满足子类的需求】

重写时，可以使用super关键字调用父类的方法

构造方法能不能被重写？【因为重写的基础就是子类继承父类的方法，而构造方法只能被调用不能被继承】

5. 方法由哪些组成

方法名参数返回值访问修饰符

方法重写的规则：

1.必须是父子关系

2.方法名必须相同

3.参数列表相同个数一样类型一样顺序一样

4.返回值类型相同

5.访问权限不能严与父类默认-public protected-public 小范围转大范围 public-protected public-private 大范围变小范围

6.父类的静太方法不能被子类覆盖为非静态方法【反过来也不行】

7.子类可以定义与父类相同名的静态方法以便在子类中隐藏父类的静态方法

8.父类的私有方法不能被子类重写【覆盖】

6. 多态

由于给的实例不同产生的结果不同，但是做的事情都是一样的

我们都是喂食由于给不同的宠物喂食那他们吃的也是不一样的

Dog是Pet的一种

以前Dog wangcai=newDog(); 旺财是一条狗

新花样 Pet wangcai=new Dog(); 旺财是一个宠物

Pet rourou=new Cat(); 肉肉是一个宠物

这就是一种新的表现形式以前是具体的对象指向具体的实例现在是父类指向具体的对象

可以通过发现都是同一种引用

也就是说pet既能接受dog 也能接受cat

继承为了收集共性我们不看细节【给单独的宠物喂】看共性【宠物喂食】

7. 向下转型

//instanceof 判断   是否能够转换

                   //instanceof两段必须为父子级关系

                   //instanceof确保程序的健壮性

                   if(wangcaiinstanceof Dog){

                            System.out.println("能");

                            Dognewwangcai=(Dog)wangcai;

                            newwangcai.lookDoor();

                   }else{

                            System.out.println("不能");

                   }

8. 向上转型

  Petwangcai=new Dog();

                   //给狗赋值属性值

                   wangcai.setName("旺财");

                   wangcai.setHanger(9);

包装类和常见类

1.枚举

枚举

避免数据误操作/安全性的另一种形式

使用：

1.定义枚举：如：public enum Sex{}

2.在类里使用枚举类型来定义属性如：private Sex sex;

3.使用枚举定义的固定值来对属性进行复制如：对象名.setSex(Sex.男);

注意：枚举中的值都是静态的常量

好处：

类型安全

输入简单

代码清晰

public enum Sex {

男,女

}

2. 包装类：

java中遵循一切皆是对象的原则，将每一个基本数据类型在java.lang包中都有一个包装类

在java.lang中是如何定义的

基本数据类型：byte short int long float double boolean char

包装类型： Byte Short Integer Long Fload Double Boolean character

为啥弄出个包装类

1.集合不允许放基本数据类型的，只能放包装类型

2.包装类可以接受空值，而基本数据类型不行

基本数据类型与包装类型的转换

定义包装类型：

Integer i=new Integer(1);

Integer j=1;

定义基本数据类型

int i=1;

包装类型转换基本数据类型

包装变量.XxxValue(); 如： .intValue()

.byteValue();

基本数据类型转包装类

构造

字符串转换对应的基本数据类型

包装类型.ParseXXX（“字符串”）

如：Stringstr="123";

int i=Integer.parseInt(str);

注意：字符串类型无法转换成char类型

装箱/拆箱

Integer i=1;

intin=i;

装箱基本数据类型转换为包装类的对象

拆箱包装类的对象转换为基本数据类型

使用场景：当基本数据类型需要用对象表示时使用

Integer陷阱

Integer i=200;

默认调用Integer类的内部方法

 public static Integer valueOf(int i) {

                   finalint offset = 128;

                   if(i >= -128 && i <= 127) { // must cache

             return IntegerCache.cache[i + offset];

                   }

       return new Integer(i);

    }

创建新的Integer对象

如果值在 -128-127之间只要我们传的值一样肯定返回一样的Integer对象

如果超出值得范围将重新创建新的Integer对象抛出，这样抛出的对象地址就会发生改变

3. Calendar类 import java.util.Calendar

//创建日期类

                   Calendar cl=Calendar.getInstance();

                   //获取当前的年

                   System.out.println(cl.get(Calendar.YEAR));

                   //返回当前月

                   System.out.println(cl.get(Calendar.MONTH)+1);

                   //返回该月的第几日

                   System.out.println(cl.get(Calendar.DAY_OF_MONTH));

                   //返回星期几

                   System.out.println(cl.get(Calendar.DAY_OF_WEEK)-1);

                   //返回一年中的第几个星期

                   System.out.println(cl.get(Calendar.WEEK_OF_YEAR));

4. Date时间工具类 import java.util.Date

//实例化date对象

                   Date date=new Date();

                   //格式化时间格式

                   //2017-9-1913:33:50

                   //实例化格式类

                  SimpleDateFormatsdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                   //格式化日期返回字符串

                   String noDate=sdf.format(date);

                   //2017-8-8

                   //把字符串转换为Date对象

                   Date date2=sdf.parse(noDate);

5. Math类 java.lang

  //rint 四舍五入

                   System.out.println(Math.rint(10.1));//10.0

                   System.out.println(Math.rint(10.5));//注意10.0

                   System.out.println(Math.rint(99.8));//100.0

                   System.out.println(Math.rint(-10.1));//-10.0

 //abs 绝对值

                   System.out.println(Math.abs(-10));//10

                   System.out.println(Math.abs(10));//10

                   System.out.println(Math.abs(-10.1));//10.1

 //Random随机数

                   (int)(Math.random()(上限-下限+下限)+下限)

//max/min

                   System.out.println(Math.max(5,6));//6

                   System.out.println(Math.min(5,6));//5

6. Random类 import java.util.Random;

注意点：Random ran=new Random(值); 不能一样

用同一个种子来初始化多个Randomd对象，然后每一个对象调用相同的方法，得到的随机数也是相同的

 一般情况下Random ran=newRandom(值); 值不写

                Random ran=new Random();  //实例化random类

//               intnum=ran.nextInt(10); //整形10以内的随机数【0-9】

//               System.out.println(num);

                   //----------------------

                   Randomran=new Random(5);  //实例化random类

                   Randomran2=new Random(4);  //实例化random类

                   int num=ran.nextInt(10); //整形10以内的随机数【0-9】

                   int num1=ran2.nextInt(10); //整形10以内的随机数【0-9】

                   System.out.println(num+"\t"+num1);  多次输出值不变

7.String 类

                   String a="ABC";
                   Stringb="abc";
                   Stringname="我叫什么你不要管反正我最帅";
                   StringuserName=" 我最 帅 ";
                   Stringshi="床前明月光,疑是地上霜,举头望明月,低头思故乡";
                  
                  //equals 字符串的比较
                   System.out.println(a.equals(b));
                
                   //length()返回字符串的长度
                   System.out.println(a.length());

                   //equalsIgnoreCase 字符串的比较不区分大小写
                   System.out.println(a.equalsIgnoreCase(b));

                   //大写转小写
                   System.out.println(a.toLowerCase());

                   //小写转大写
                   System.out.println(b.toUpperCase());

                   //indexOf("str") 从下标0开始查找该字符第一次出现的下标     字符串的下标从0开始  没有找到返回-1
                   System.out.println(name.indexOf("你"));

                   //indexOf("str",index) 从下标index开始查找该字符第一次出现的下标  没有找到返回-1
                   System.out.println(name.indexOf("你",5));

                   //lastIndexOf("str") 从下标   .length-1   开始往前查找str最后一次出现的位置 返回其下标  未找到返回-1
                   System.out.println(name.lastIndexOf("我"));

                   //lastIndexOf("str",index) 从下标  index   开始往前查找str最后一次出现的位置 返回其下标  未找到返回-1
                   System.out.println(name.lastIndexOf("正",8));

                   //substring(index) 截取index之后的所有字符  包括index下标的字符
                   System.out.println(name.substring(5));

                   //substring(index1,index2) 截取index1-index2之间的所有字符  包括index下标的字符 不包括index2下的【index1-index2-1】
                   System.out.println(name.substring(5,8));

                   //trim()去除字符串两端的空格
                   System.out.println(userName);
                   System.out.println(userName.trim());

                   //split("str") 以str符号将字符串拆分为数组
                   String[] st=shi.split(",");
                   for(Strings : st){
                            System.out.println(s);
                   }

                   //charAt(index)  返回索引为index对应的字符  为char类型
                   System.out.println(shi.charAt(5));

                   //replaceAll("str","newstr")  将str替换成newstr 并返回替换之后的新新字符串
                   System.out.println(shi.replaceAll("前","后"));        

                   //字符串的链接+
                   //str1.concat(str2)     将str1和str2字符串的链接
                   System.out.println(a+b);
                   System.out.println(a.concat(b));

8.StringBuffer和string的区别

string对象一旦产生就不可以被修改，重新赋值其实是俩个对象【变量只是换了一个地址而已】

StringBuffer对象的内容可以修改，StringBuffer在进行字符串的处理时，不会生产新的对象，在内存使用上优于String

如果经常需要对一个字符串进行修改

String 在String类中没有方法用来改变自己的

StringBuffer可以更简单的使用插入/删除等操作

StringBuffer 线程安全

如何使用StringBuffer

                //字符串的追加
                   sb.append("帅");
                   sb.append("的掉渣");
                   sb.append(",骗你的")；
                   //插入  insert(index,"str");  在index的位置插入一个字符str
                   sb.insert(1, "6");
                   //替换replace(index1,index2, "str")  将index1-index2-1之间的字符替换为str
                   sb.replace(2,5, "0");               
                   //将StringBuffer 转换成String
                   System.out.println(sb.toString());

异常

1. 异常

异常是阻止当前方法或作用域继续执行的问题，在程序中导致程序中断运行的一些指令。

程序中的异常有哪些

除数为0

怎么来解决异常的：使用异常结构

异常的结构：

       try{

             //可能出现异常的代码

           }catch(捕获异常的类型  对象){//如果产生的异常类型和捕获的类型相同就值catch块  如果不同无法捕获 系统自己输出异常信息

             //输出异常信息

             System.err.print("错误信息");   //err提高输出级别

             printStackTrace()    //调用异常类的内部方法 输出异常的全部信息

             getMessage();  //调用异常类的内部方法输出异常的信息   返回一个字符串

           }finally{

             //无论是否发生异常 最终执行的模块

           }

//4种不执行finally的突发情况？

1.在finally块里发生了异常

2.在catch块里或在try块里使用了System.exit(1);退出java虚拟机

3.程序所在的线程死亡

4.关闭CPU

异常处理过程

1.一旦产生异常，则系统会自动产生一个异常类的实例化对象

2.此时如果出现错误存在try语句，则会自动找到匹配的catch语句执行，如果没有找到异常处理，则程序执行完退出，系统报告错误

3.所有的catch根据方法的参数匹配异常的实例化对象，如果匹配成功则表示由此 catch进行异常处理，并输出异常信息

在异常里带return语句的执行流程【面试题】

正确：先执行try的代码再执行finally 最后执行return；

出异常的情况：先执行try的代码在执行对应异常信息的catch 最后执行finally

异常的结构及其作用

try:放置可能出现异常的代码，用于捕获异常，其后可以接0个或多个catch块，如果没有catch块，则必须有一个finally块

catch:处理异常捕获的异常

finally:无论是否出现异常都会执行注意:1不执行的4种，有return的执行流程

多重catch

注意点：catch可以有多个，但是catch的排序必须是由子到父

1.7 catch中的异常类可以追加|连写，但是作用同一个代码

2.throw/throws

throw生成异常

写在方法内部的，可以单独使用

生成的异常只能是一个

throws声明方法内抛出的异常类型

必须跟在方法参数列表的后面，不能单独使用

抛出可以抛出多个

3.开源日志记录工具log4j

使用步骤

1.在项目中加入log4j的JAR文件

2.创建log4j.properties文件

3.配置日志信息

4.使用log4j记录日志信息

private static Loggerlogger=Logger.getLogger(RiZi.class);

logger.error("日志信息");

配置日志信息

日志记录器输出级别：fatal> error > warn > info >debug

### 设置Logger输出级别和输出目的地 ###

log4j.rootLogger=debug, stdout,logfile

### 把日志信息输出到控制台 ###

log4j.appender.stdout=org.apache.log4j.ConsoleAppender //日志信息输出到控制台

log4j.appender.stdout.Target=System.err //信息打印到System.err上

log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout //指定日志布局类型

### 把日志信息输出到文件：jbit.log###

log4j.appender.logfile=org.apache.log4j.FileAppender //日志信息写到文件中

log4j.appender.logfile.File=jbit.log //指定日志输出的文件名

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout //指定转换模式

log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-ddHH:mm:ss} %l %F %p %m%n

//指定日志布局类型

chaunceny

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
类和对象

类和对象1. 什么是面向对象？ 1.面向对象是一种编程思想 2.面向对象是一种思考问题的方式 2. 面向对象的基础？类对象属性方法 3. 什么是类？ 1.类：分类，类别 2.通过分类：饿哦们可以区分不同的事物种类，在日常生活中我们就是这么分类的 ...
复制链接

扫一扫

专栏目录