Java 程序设计（面向对象）- 相关内容，linux 操作系统和 arm 架构
抽象类的成员特点：
成员变量
可以有成员变量
可以有常量
成员方法
可以有抽象方法
可以有非抽象方法
构造方法
可以有构造方法的，需要对抽象类的成员变量进行初始化
例如：
package com.itxbj_01;
/*
抽象类的成员特点：
final:修饰类、成员变量、成员方法
*/
public class AbstractDemo3 {
public static void main(String[] args) {
Dog d = new Dog();
d.barking();
}
}
abstract class Animal {
String name = "哮天犬";
final int num = 10;
public Animal() {
System.out.println("我是抽象类的构造方法");
}
public abstract void eat();
public void run() {}
}
class Dog extends Animal {
public void barking() {
System.out.println(name);
System.out.println(num);
}
@Override
public void eat() {
// TODO Auto-generated method stub
}
}
抽象类关键字 abstract 可以和哪些关键字共存?
private：
私有的方法子类是无法继承到的，也不存在覆盖，而 abstract 和 private 一起使用修饰方法，abstract 既要子类去实现这个方法，而 private 修饰子类根本无法得到父类这个方法。互相矛盾。
final:
抽象类不能和 final 共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用 final 关键字,那么抽象类就没有子类
抽象方法不能和 final 共存,因为抽象方法后期需要被子类重写,一旦加 final 无法重写
static:
抽象方法不能和 static 关键字共存,因为一旦加 static 我们就可以通过类名直接访问抽象方法,由于抽象方法没有方法体,没有任何意义,也不允许这样做
抽象类中是否可以不定义抽象方法?
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
抽象类是否有构造函数?
有,抽象类的构造函数,是由子类的 super 语句来调用,用于给抽象类中的成员初始化
================================================================
接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。
与定义类的 class 不同，接口定义时需要使用 interface 关键字。
定义接口所在的仍为.java 文件，虽然声明时使用的为 interface 关键字的编译后仍然会产生.class 文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
定义格式：
public interface 接口名 {
抽象方法 1;
抽象方法 2;
抽象方法 3;
}
接口中的方法全是抽象方法,直接 new 接口来调用方法没有意义,Java 也不允许这样干
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用 implements
其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。
格式：
class 类 implements 接口 {
重写接口中方法
}
在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
例如：
package com.itlishan_01;
/*
Java 语言的继承是单一继承，一个子类只能有一个父类（一个儿子只能有一个亲爹）
Java 语言给我们提供了一种机制，用于处理继承单一的局限性的，接口
接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现，implements
interface
格式：
*/
public class InterfaceDemo {
public static void main(String[] args) {
BillGates gates = new BillGates();
gates.code();
}
}
class Boss {
public void manage() {
System.out.println("管理公司");
}
}
class Programmer {
public void code() {
System.out.println("敲代码");
}
}
//比尔盖茨
class BillGates extends Programmer {
}
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解 fnal 关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
例如：
package com.itlishan_01;
/*
接口的成员特点：
建议：建议大家手动的给上默认修饰符
注意：
*/
public class InterfaceDemo2 {
public static void main(String[] args) {
//Animal a = new Animal();
//Animal.num;
}
}
interface Animal {
public static final int num = 10;
public abstract void eat();
}
class Cat implements Animal {
public void eat() {
}
}
A:类与类之间:继承关系,一个类只能直接继承一个父类,但是支持多重继承
B:类与接口之间:只有实现关系,一个类可以实现多个接口
C:接口与接口之间:只有继承关系,一个接口可以继承多个接口
例如：
package com.itlishan_01;
/*
类与类：继承关系，单一继承，多层继承
类与接口：实现关系，多实现
接口与接口的关系：继承关系，多继承
*/
public class InterfaceDemo3 {
public static void main(String[] args) {
}
}
interface InterA extends InterB {
public abstract void method();
}
interface InterB {
public abstract void function();
}
interface InterC extends InterA {
}
class Demo implements InterC {
@Override
public void method() {
// TODO Auto-generated method stub
}
@Override
public void function() {
// TODO Auto-generated method stub
}
}
前面讲述了接口的代码体现，现在来学习接口的思想，接下里从生活中的例子进行说明。
举例：我们都知道电脑上留有很多个插口，而这些插口可以插入相应的设备，这些设备为什么能插在上面呢？主要原因是这些设备在生产的时候符合了这个插口的使用规则，否则将无法插入接口中，更无法使用。发现这个插口的出现让我们使用更多的设备。
接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（插在插口上的设备）。例如：笔记本使用这个规则（接口），电
《一线大厂 Java 面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》
【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享
脑外围设备实现这个规则（接口）。
集合体系中大量使用接口
Collection 接口
List 接口
ArrayList 实现类
LinkedList 实现类
Set 接口
1.类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，类与类之间是继承关系，java 中的继承是单一继承，一个类只能有一个父类，打破了继承的局限性。
2.对外提供规则（USB 接口）
3.降低了程序的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）
1.共性：
不断的进行抽取，抽取出抽象的，没有具体实现的方法,都不能实例化（不能创建对象）
2.区别 1: 与类的关系
(1)类与接口是实现关系，而且是多实现，一个类可以实现多个接口，类与抽象类是继承关系，Java 中的继承是单一继承，多层继承，一个类只能继承一个父类，但是可以有爷爷类
(2)区别 2： 成员
成员变量
抽象类可以有成员变量，也可以有常量
接口只能有常量，默认修饰符 public static final
成员方法
抽象类可以有抽象方法，也可以有非抽象方法
接口只能有抽象方法，默认修饰符 public abstract
构造方法
抽象类有构造方法，为子类提供
接口没有构造方法
例如：
package com.itlishan_02;
/*
篮球运动员和教练
乒乓球运动员和教练
现在篮球运动员和教练要出国访问,需要学习英语
请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
*/
public class InterfaceTest {
public static void main(String[] args) {
//创建篮球运动员对象
BasketBallPlayer bbp = new BasketBallPlayer();
bbp.name = "女兆月日";
bbp.age = 35;
bbp.gender = "男";
bbp.sleep();
bbp.study();
bbp.speak();
System.out.println("-------------");
//创建乒乓球教练对象
PingpangCoach ppc = new PingpangCoach();
ppc.name = "刘胖子";
ppc.age = 40;
ppc.gender = "男";
ppc.sleep();
ppc.teach();
//ppc.speak();
}
}
class Person {
String name;//姓名
int age;//年龄
String gender;//性别
//无参构造
public Person() {}
//有参构造
public Person(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//吃
public void eat() {
System.out.println("吃饭");
}
//睡
public void sleep() {
System.out.println("睡觉");
}
}
//学习说英语
interface SpeakEnglish {
public abstract void speak();
}
//运动员
abstract class Player extends Person {
//学习
public abstract void study();
}
//教练
abstract class Coach extends Person {
//教
public abstract void teach();
}
//篮球运动员
class BasketBallPlayer extends Player implements SpeakEnglish{
@Override
public void study() {
System.out.println("学扣篮");
}
@Override
public void speak() {
System.out.println("说英语");
}
}
//乒乓球运动员
class PingpangPlayer extends Player {
@Override
public void study() {
System.out.println("学抽球");
}
}
//篮球教练
class BasketBallCoach extends Coach implements SpeakEnglish {
@Override
public void teach() {
System.out.println("教扣篮");
}
@Override
public void speak() {
System.out.println("说英语");
}
}
//乒乓球教练
class PingpangCoach extends Coach {
@Override
public void teach() {
System.out.println("教抽球");
}
}
=================================================================
什么是内部类
将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
什么时候使用内部类
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。
class 汽车 { //外部类
class 发动机 { //内部类
}
}
成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
例如：
package com.itxbj_01;
/*
成员内部类：
*/
public class InnerDemo {
public static void main(String[] args) {
//Outer o = new Outer();
//o.method();
Outer.Inner i = new Outer().new Inner();
i.function();
}
}
class Outer {
private int num = 10;
public void method() {
Inner i = new Inner();
i.function();
}
class Inner {
public void function() {
System.out.println(num);
}
}
}
成员内部类
成员内部类可以使用的修饰符:private,public,procted,final,static,abstract
例如：
package com.itxbj_01;
/*
成员内部类的修饰符：
我们可以使用 abstract,final 修饰成员内部类
*/
public class InnerDemo2 {
public static void main(String[] args) {
//Outer2.Inner2 i;
//Outer2.Inner2 i = new Outer2.Inner2();
//i.function();
Outer2.Inner2.function();
}
}
class Outer2 {
public void method() {
Inner2 i = new Inner2();
}
static class Inner2 {
public static void function() {
System.out.println("function");
}
}
}
局部内部类
局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
访问方式
在外部类方法中，创建内部类对象，进行访问
例如：
package com.itxbj_02;
/*
局部内部类
*/
public class InnerDemo3 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
class Outer {
public void method() {
int num = 10;
class Inner {
public void function() {
System.out.println("function");
}
}
Inner i = new Inner();
i.function();
}
public void test() {
//Inner i = new Inner();
//System.out.println(num);
}
}
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
总结：心得体会
既然选择这个行业，选择了做一个程序员，也就明白只有不断学习，积累实战经验才有资格往上走，拿高薪，为自己，为父母，为以后的家能有一定的经济保障。
学习时间都是自己挤出来的，短时间或许很难看到效果，一旦坚持下来了，必然会有所改变。不如好好想想自己为什么想进入这个行业，给自己内心一个答案。
面试大厂，最重要的就是夯实的基础，不然面试官随便一问你就凉了；其次会问一些技术原理，还会看你对知识掌握的广度，最重要的还是你的思路，这是面试官比较看重的。
最后，上面这些大厂面试真题都是非常好的学习资料，通过这些面试真题能够看看自己对技术知识掌握的大概情况，从而能够给自己定一个学习方向。包括上面分享到的学习指南，你都可以从学习指南里理顺学习路线，避免低效学习。
大厂 Java 架构核心笔记（适合中高级程序员阅读）：
还未添加个人签名 2021.11.12 加入
还未添加个人简介
评论