5.2 继承、关联、实现
6、Object类中的方法
6.1 toString方法
6.2 equals方法
6.3 finalize方法
7、继承关系的数组
8、Array工具类
8.1 排序
8.2 二分法查找
9、StringBuffer
9.1 在字符串拼接时的资源浪费
9.2 优化程序引入StringBuffer
10、String、int、Integer三者的转换
1、JVM三大内存的存储情况
==============
1)局部变量存储在栈内存当中;
2)实例变量在构造方法进行的时候初始化,存在堆内存中(成员变量的一种) 实例语句块在构造方法执行之前
3)静态变量在类加载的时候初始化,存在方法区内存中(成员变量的一种) 静态代码块在类加载的时候执行,且执行一次
4)方法的代码片段在方法区内存中,方法区内存中是首先被使用的JVM区域
5)对象在堆内存,对象的引用在栈内存
2、对多态的理解
========
2.1 向下转型使用多态,降低程序的耦合度,提供扩展力
public class Sttt {
public static void main(String[] args) {
Master master1 = new Master();
Dog Tom = new Dog();
Cat Amy = new Cat();
master1.feed(Tom);
master1.feed(Amy);//这里传入Amy会自动向上转型成Pet类型
//master.feed(new Dog());
//master.feed(new Cat());
//也可以通过这种方式相当于Pet pet = new Dog()
Master master2 = new Master();
Pet T = new Dog();
Pet A = new Cat();
master2.feed(T);
master2.feed(A);//这里传入的是Pet类型
}
}
class Master{
public void feed(Pet pet){
pet.eat();
}
}
class Pet{
public void eat(){
}
}
class Cat extends Pet{
public void eat(){
System.out.println(“猫在吃鱼!”);
}
}
class Dog extends Pet{
public void eat(){
System.out.println(“狗啃骨头!”);
}
}
2.2 向上转型来访问子类中特有的方法和属性
public class Sttt {
public static void main(String[] args) {
Pet Tom = new Cat();
//Tom.catch();不能这么写,虽然底层是Cat,但是是Pet类型,此时需要向下转型
Cat T = (Cat)Tom;
T.catch();
}
}
class Master{
public void feed(Pet pet){
pet.eat();
}
}
class Pet{
public void eat(){
System.out.println(“宠物进食!”);
}
}
class Cat extends Pet{
public void eat(){
System.out.println(“猫在吃鱼!”);
}
public void catch(){
System.out.println(“抓老鼠!”);
}
}
class Dog extends Pet{
public void eat(){
System.out.println(“狗啃骨头!”);
}
}
3、super关键字
==========
3.1 关于super
1)super(实参列表)通过当前的构造方法去调用**“父类”**中的构造方法,目的是:创建子类对象的时候,先初始化父类型特征,实现代码复用;
2)重要结论: 当一个构造方法的第一行: 既没有this()又没有super()【this()和super()不能共存】的话,默认会有一个super(); 表示通过当前子类的构造方法调用父类的无参数构造方法,所以必须保证父类的无参构造方法是存在的;
3)理解:super的作用:模拟现实世界要想有儿子,必须把父亲造出来;它代表的是当前对象(this)的父类型特征;
4)无论怎么折腾,父类的构造方法都会先执行;
不管创建什么对象,老祖宗的object类的无参构造方法一定会执行(object类中的构造方法是处于"栈顶部",最后调用最先结束)
5)super不是引用,不保存内存地址,也不指向任何对象,只是代表当前对象内部那一刻父类型的特征;
6)"super."后面不仅可以访问属性,还可以访问方法;
3.2 对super的理解练习1
public class Sttt {
public static void main(String[] args) {
new B();
}
}
class A{
int a =10;
public A() {
System.out.println(“A的构造方法”);
}
public void b(){
}
}
class B extends A{
public B(){
this(“zhangsan”);
super.a//super.在构造方法中调用父类的属性
System.out.println(“B的构造方法”);
}
public B(String name){
super();
super.b();//super.b()在构造方法中调用父类的方法
System.out.println(“B的带参构造方法”);
}
}
3.3 对super的理解练习2
public class Super {
public static void main(String[] args) {
new C();
}
}
/*class Object{
public Object(){
}
}*/
class A /extends Object/{//Object这个是Sun公司写的
public A() {
//有super()
System.out.println(“1”);
}
}
class B extends A{
public B(){
//有super()
System.out.println(“2”);
}
public B(String name){
//有super()
System.out.println(“3”);
}
}
class C extends B{
public C(){
this(“zhangsan”);
System.out.println(“4”);
}
public C(String name){
this(name,20);
System.out.println(“5”);
}
public C(String name,int age){
super(name);
System.out.println(“6”);
}
}//结果是1 3 6 5 4
4、抽象类
=====
4.1 关于抽象类
-
类与类之间具有共同特征,将这些共同特征提取出来,形成的就是抽象类;
-
类本身是不存在的,属于抽象类无法创建对象【无法实例化】;
-
抽象类是用来被子类继承的;
-
finial关键字和abstract关键字不能同时出现;
-
抽象类的子类可以是抽象类;
-
抽象类虽然无法实例化,但有构造方法,这个构造方法是供子类使用的;
-
接口一般描述的是行为动作信息
-
一个非抽象的类继承抽象类,必须把抽象类中的抽象方法给实现(覆盖、重写)了
public class Sttt {
public static void main(String[] args) {
new B();
}
}
abstract class A{
int a =10;
public A() {
}//抽象类有构造方法,供子类使用
public abstract void b();//抽象方法没有方法体
}
class B extends A{
public void b(){
}//非抽象类继承抽象类必须重写抽象方法
}
4.2 抽象方法
1)抽象方法表示没有实现的方法,没有方法体,以分号结尾的方法。例如:
public abstract void doSome();
2)抽象类中不一定有抽象方法,但抽象方法一定在抽象类当中;
3)没有方法体的方法不一定都是抽象方法,Object类中就有很多方法都没有方法体,以" ;"结尾 e.g.:public native int hashCode();这个方法底层调用了C++写的动态链接库程序;前面修饰符列表中有native,表示调用JVM本地程序
5、接口
====
5.1 关于接口
1)接口也是一种引用数据类型,
2)接口的完全抽象的(抽象类是半抽象类)或者也可以说接口是特殊的抽象类;
3)接口支持接口继承也支持接口多继承;
interface A{
}
interface B{
}
interface C extends A,B{
}
4)接口中只包含两部分内容,一部分是常量,另一部分是抽象方法,所有内容都是public修饰的,都是公开的;
5)接口中抽象方法中的public static 可以省略,"public abstract int sun(int a,int b);" ——> "int sun(int a,int b);"
6)接口中变量中的public static final 可以省略,”public static final double PI = 3.1415926;" —> "double PI = 3.1415926;;"
7)接口中的方法都是抽象方法,所以接口中的方法都没有方法体;
public class Sttt {
public static void main(String[] args) {
MyMath m = new MyMathImp();//面向接口编程,父类型引用指向子类型对象
System.out.println(m.sub(10,2));
}
}
interface MyMath{
double PI = 3.1415926;//public static 可以省略
int sum(int a,int b);//public static 可以省略
int sub(int a,int b);
}
class MyMathImp implements MyMath{
public int sum(int a,int b){//当一个非抽象的类实现接口的话,必须将接口中所有的抽象方法全部实现(覆盖、重写)
return a+b;
}
public int sub(int a,int b){//非抽象的类实现接口时重写的抽象方法public不可省
return a-b;
}
}
一个类可以实现多个接口,这种机制弥补了"java中类和类只支持单继承"带来的缺陷;
接口和接口之间在进行强制类型转换的时候,没有继承关系,也可以强转,但运行的时候可能会出现ClassCastException异常,需要加instanceof进行判断;
public class HelloWorld{
public static void main(String[] args) {
//如何实现多态???
A a = new C();
if(a instanceof B){
B b2 = (B)a;//此时a b的底层都是C,C实现了接口A和接口B,所以可以向下转型
b2.m2();
}
M m = new E();
if(m instanceof K){
K k = (K)m;//这里的E()和K没有关系,E实现了M,但没有实现接口K,所以不能向下转型
k.m3();
}
}
}
interface A{
void m1();
}
interface B{
void m2();
}
class C implements A,B{//C实现了A和B
public void m1(){
}
public void m2(){
System.out.println(“可以向下转型!”);
}
}
interface K{
void m3();
}
interface M{
void m4();
}
class E implements M{//E实习了M,但没有实现K
public void m3(){
}
public void m4(){
}
4)继承和实现都存在的话,代码怎么写?
public class Sttt {
public static void main(String[] args) {
Flyable f = new Cat();
f.Fly();
}
}
class Animal{
}
interface Flyable{
void Fly();
}
class Cat extends Animal implements Flyable{
public void Fly(){
System.out.println(“猫会飞!”);
}
}
5)点餐问题
public class Sttt {
public static void main(String[] args) {
Meau meau = new ChineseCook();
Customer customer = new Customer(meau);
customer.order();
}
}
class Customer{
private Meau meau;
public void setMeau(Meau meau) {
this.meau = meau;
}
public Meau getMeau() {
return meau;
}
public Customer() {
}
public Customer(Meau meau) {
this.meau = meau;
}
public void order(){
meau.Chaodan();
meau.XiHongShi();
}
}
interface Meau{
void Chaodan();
void XiHongShi();
}
class ChineseCook implements Meau{
public void Chaodan(){
System.out.println(“炒蛋”);
}
public void XiHongShi() {
System.out.println(“西红柿”);
}
}
5.2 继承、关联、实现
is a:继承
Cat is a Animal;(猫是一个动物)
凡是满足is a的表示都可以设置为“继承”;
A extends B
has a:关联
I has a Animal;(我有一支笔)
凡是能够用has a来描述的,统一以“属性(关联)”的方式存在;
A{
B b;
}
like a:实现
Cook like a FoodMeau;(厨师像一个菜单一样)
凡是能够满足like a关系的表示类“实现”接口;
A implement B;
6、Object类中的方法
=============
6.1 toString方法
public class Sttt {
public static void main(String[] args) {
Time t = new Time(2008,8,8);
System.out.println(t.toString());
}
}
class Time{
int year;
int month;
int day;
public Time(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public Time() {
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
最后
文章中涉及到的知识点我都已经整理成了资料,录制了视频供大家下载学习,诚意满满,希望可以帮助在这个行业发展的朋友,在论坛博客等地方少花些时间找资料,把有限的时间,真正花在学习上,所以我把这些资料,分享出来。相信对于已经工作和遇到技术瓶颈的朋友们,在这份资料中一定都有你需要的内容。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public Time() {
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。[外链图片转存中…(img-INB6HlsH-1713432494873)]
[外链图片转存中…(img-x5XpZg9V-1713432494874)]
[外链图片转存中…(img-q9CXwMgd-1713432494874)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
最后
文章中涉及到的知识点我都已经整理成了资料,录制了视频供大家下载学习,诚意满满,希望可以帮助在这个行业发展的朋友,在论坛博客等地方少花些时间找资料,把有限的时间,真正花在学习上,所以我把这些资料,分享出来。相信对于已经工作和遇到技术瓶颈的朋友们,在这份资料中一定都有你需要的内容。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!