Java基础_第一篇-Aet

Bingliaolong 2020-08-31 15:45 Aet | 隐藏边栏 | 抢沙发 | 0 0

文章评分 0 次，平均分 0.0 ：

Java特点

面向对象
- 纯面向对象
- 万物皆对象
- 所有的元素都要通过类和对象来访问
分布性
- 操作分布
- 在多个不同的主机上布置相关操作
- 这些主机是网络中的不同成员
- 数据分布
- 讲数据存放在多个不同的主机上
- 这些主机是网络中的不同成员
- Java可以拼接URL对象访问网络对象
可移植性
- 可以非常方便的移植到网络中的不同计算机上
解释型
- 运行Java程序需要解释器
- 任何移植了Java解释器的计算机或者其他设备都可以用Java字节码进行解释执行
- 字节码是独立于平台的，它本身携带了许多编译时的信息，使得连接过程更加简单
安全性
- Java语言删除了类C语言中的指针和内存释放等语法，有效的避免了用户对内存的非法操作
- Java程序代码要经过代码校验、指针校验等很多测试步骤才能够运行，所以未经允许的Java程序不可能出现损害系统平台的行为
健壮性
- Java会检查程序在编译时或运行时的错误，并消除错误
多线程
- 多线程机制能够使得应用程序在同一时间并行执行多项任务，而且相应的同步机制可以保证不同线程能够正确的共享数据。
高性能
- Java编译后的字节码是在解释器中运行的，所以他的速度较多数交互式应用程序提高了很多
- 字节码可以在程序运行时被翻译成特定平台的机器指令，从而进一步提高运行速度
动态
- 可以动态调整库中方法和增加变量，而客户端却不需要任何更改

重载

在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或者类型不同即可。

Tips

参数不定长方法

语法：

返回类型方法名（参数数据类型...参数名称)
上面这种形式定义了参数不定长的方法，以"..."的形式，其实呢，这儿参数名称，在这个地方其实是一个数组
编译器会将<code>int...a<code>看成int[]a来处理

继承

在java中，用extends关键字来表示继承关系

class Test {

public Test() {

//something

}

protected void doSomeThing() {

//doSomeThing

}

protected Test doIt() {

return new Test();

}

class TestNew extends Test {

public TestNew() {

Super();

Super.doSomeThing();

}

pulic void doSomeThingNew() {

//doSomeThingNew

}

public void doSomeThing() {

}

public TestNew doIt() {

return new TestNew();

}

使用super（）可以调用父类的构造
也可以使用super关键字调用父类中的方法

java中对象类型的转型

向上转型

通俗的讲：
就是把子类类型的对象赋给父类类型的变量
这个就是多态的基本思想了

而且，由于向上转型也就是说把子类对象赋给父类类型的变量，是从具体到抽象的一个过程，所以，它总是安全的

向下转型

向下转型也就是，将父类对象赋给子类对象

但是，在操作的时候，不能直接把父类对象赋给子类对象，会引发错误

因为父类对象越是位于子类对象的上层，对于这个子类对象来讲，这个父类对象就会越抽象，特性也越少。那么，向下转型的时候，如果直接把父类对象赋值给子类对象，编译器会告诉我们这个转换会出问题

怎么做？
告诉编译器，我们赋给子类对象的父类对象，它就是一个子类对象，让编译器不用担心
显示类型转换！（强制类型转换）

class father {

//something

}

class son extends father {

...

static void main(String args[]) {

father f = new father();

son s = f;//错误

son s = (son) f;//正确

}

多态

多态就是指程序中定义的变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定

而是在程序运行期间才确定

即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须由程序运行期间才能决定

因为，它在程序运行期间才确定具体是哪个类

这样的好处

就是可以不用修改源码程序，就可以让引用变量绑定到各种不同的类的实现上，从而导致该引用变量调用的具体方法也是随之改变的

总体的效果，就是让程序可以根据实际情况来选择运行多个运行状态中的一个

这个就是多态性

抽象类

在解决实际问题的过程中，一般会把父类定义为抽象类

因为可能需要用来父类来实现继承和多态的机制

继承的话，越往上的类越抽象

多态的话，它不需要管父类是怎样的，它需要的子类的实例对象

在java语言中，设置抽象类为不可实例化对象

就是某个类被设置成抽象类了，我们就不可以实例化它

语法：

public abstract class Test {

//定义抽象方法

abstract void testAbstract();

}

其中，abstract是定义抽象类的关键字

使用了abstract的类是抽象类，使用了abstract的方法是抽象方法

抽象方法是没有实体的，因为对它写个实体没有任何意义，它只有被继承以后实现方法实体才有意义

反过来讲，只要某个类中有抽象方法，那么这个类就是抽象类

抽象类被继承后，需要实现其中所有的抽象方法

接口

接口是抽象类延生，可以将它看作是纯粹的抽象类
接口中的所有方法都没有实体

语法：

public interface drawTest {

//接口内的方法，省略abstract关键字

void draw();

}

public:接口同样可以像类一样被权限修饰符修饰，但public关键字仅限用于接口在与其同名的文件中被定义
interface：定义接口的关键字
drawTest：接口名称

一个类实现一个接口，可以使用implements关键字

实例：

public class Parallelogram extends Quadrangle implements drawTest {

//...

}

注意：

在接口中，方法必须被定义为public或者abstract形式，其他权限修饰符不被java编译器认可

在接口中定义的任何字段，都自动是static和final的

实例代码

interface drawTest {

public void draw();

}

//定义平行四边形类，该类继承了四边形类，并实现了drawTest接口

class ParallelogramgleUseInterface extends QuadrangleUseInterface implements drawTest{

public void draw() {

System.out.println("平行四边形.draw");

}

public void doAnyThing() {

//do something 覆盖父类的方法

}

calss SquareUseInterface extends QuadrangleUseInterface implements drawTest {

public void draw() {

System.out.println("正方形.draw")；

}

public void doAnyThing() {

//dosomething

}

class AnythingUseInterface extends QuadrangleUseInterface {

public void doAnyThing() {

//dosomething

}

//四边形类

public class QuadrangleUseInterface {

public void doAnyThing() {

//dosomething

}

public static void main(String[] args) {

//对接口进行向上转型操作，让这些接口变成对应父类的方法

draw Test[] d = {new SquareUseInterface(),new ParallelogramgleUseInterface()};

for(int i=0;i < d.length(); i++) {

d[i].draw();

}

结果：

分别调用了正方形和平行四边形类的draw函数

接口与继承

java中不允许出现多重继承
但是，使用接口的机制就可以实现多重继承
一个类可以同时实现多个接口，所以可以将需要被继承的接口放置在implements关键字后面，并使用逗号隔开

这种做法，可能会导致一个类出现大量的代码，因为继承一个接口时，需要实现这个接口里的所有方法

语法：

1	class 类名 implements 接口1，接口2，...，接口n

还可以在定义一个接口时，继承其他的接口

interface inf1 {

}

interface inf2 extends inf1 {

}

Instanceof

可以使用instanceof操作判断一个类是否实现了某个接口
也可以用来判断一个实例对象是不是属于一个类

当程序需要向下转型的时候，如果父类的对象不是子类的额实例对象，就会发生ClassCastException异常

一个好的习惯是，在每次进行向下转型之前，都对这个父类的实例对象进行一个判断，判断一下这个实例对象是不是属于子类

使用`instanceof`来实现这种判断

语法：

myobject instanceof SonClass

//myobject 某个类的对象实例

//SonClass 某个类

示例：

class Father {

//something

}

class Son1 extends Father {

//something

}

class Son2 extends Father {

//something

}

class Anything {

//something

}

public class Son3 extends Father {

static void main(String args[]) {

Father lif = new Father();

if (lif instanceof Son3)//是

Son3 wx = (Son3)lif;//转型

}

Java类包

java中每定义好一个类，通过编译器编译之后，就会生成一个扩展名为.class的文件

当系统的规模变得庞大之后，就很容易发生命名冲突的现象

而Java语言中就提供一种管理类文件的机制，叫类包

类名冲突

Java中每个接口和类都来自不同的类包
无论是Java Api中的类与接口还是开发者自定义的类与接口，都需要隶属于某一个类包

类路径

一个完整的类名是：包名+类名这样的一种组合

所以

只要保证同一类包中的类不重名，就可以有效避免同名类的冲突情况

因此

要在程序中指定完整的类路径，编辑器才会准确区分出某些同名类各自隶属于哪个包

创建包

在src节点，new-package
输入包名

导入包

使用import关键字进行导入

//指定com.lzw包中的所有类在程序中都可以使用

import com.lzw.*;

//指定com.lzw包中的Math类在程序中可以使用

import com.lzw.Math；

import还可以导入静态成员

语法：

1	import static 静态成员

用法：

package com.lzw;

//导入静态成员方法

import static java.lang.Math.max;

//导入静态成员变量

import static java.lang.System.out;

public class ImportTest {

public static void main(String[] args) {

out.println("1+4"+max(1,4));

}

final

final关键字用于声明变量
使用该关键字声明的变量，一旦被设定，其值就不可以再被改变了
也就是，在java中，使用final关键字来定义的常量

示例：

1	final double PI = 3.14;

注意：

和C++的const常量一样，在java中，使用final声明的常量也要在声明时进行初始化赋值

另：

final还可以用来修饰对象引用
一旦一个对象被修饰为final之后，它就不能再指向其他另一个对象
一个既是static 又是final的字段只占据一段不能改变的存储空间

示例code:

package com.lzw;

import static java.lang.System.out;

import java.util.Random;

class Test {

int i = 0;

}

public class FinalData {

static Random rand = new Random();

//声明一个final常量

private final int VALUE_1 = 9;

//声明一个static的final常量

private static final int VALUE_2 = 10;

//声明一个final引用

final Test test1 = new Test();

//不是final引用

private Test test2 = new Test();

//声明一个定义为final的数组

private final int[] a = {1,2,3,4,5,6,7,8,9,10};

private final int i4 = rand.nextInt(20);

private static final int i5 = rand.nextInt(20);

public String toString() {

return i4 + " " + i5 + " ";

}

public static void main(String[] args) {

FinalDate data = new FinalData();

//可以对定义为final的引用中的成员赋值

//但不能将定义为final的引用指向其他引用

data.test1 = new Test();

out.println(data);

out.println(new FinalData());

}

在java中定义全局常量

1	public static final 类型变量名 = 初值；

final方法

定义为final的方法不能被重写
why?将方法定义为final，可以防止子类修改该方法的定义和实现
- 将方法定义为final，可以防止子类修改该方法的定义和实现
- 同时，定义为final类型的方法执行效率要高于非final类型的方法

相比较与private：

如果一个父类的某些方法被定义成了private，那么子类就无法访问该方法了，自然也就无法覆盖。

也就是说
定义为private类型的方法是被隐式指定为final类型的，当然也就没有必要将一个private类型的方法再定义为final类型了

fianl类

定义为final的类不能被继承

注意：
如果某个类被定义成了final类型，那么这个类里面的所有方法都被隐式设置为final形式
但是，类中的成员变量却是可以设置为final类型或者不是final类型

Code:

final class FinalClass {

int a = 3;

void doit() {

}

public static void main(String[] args) {

FinalClass f = new FinalClass();

f.a++;

System.out.println("f.a");

}

Java特点
重载
Tips
继承
java中对象类型的转型
向上转型
向下转型
多态
抽象类
接口
接口与继承
Instanceof
Java类包
类名冲突
类路径
创建包
导入包
final
final方法
fianl类

java

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2021-11-20

Everything will be better.

你可能也喜欢

热评文章

* 暂无

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

Java特点

重载

Tips

继承

java中对象类型的转型

向上转型

向下转型

多态

抽象类

语法：

接口

语法：

实例：

注意：

实例代码

结果：

接口与继承

Instanceof

使用`instanceof`来实现这种判断

语法：

示例：

Java类包

类名冲突

类路径

创建包

导入包

final

注意：

另：

示例code:

final方法

相比较与private：

fianl类

注意：

Code:

你可能也喜欢

热评文章

发表评论

标签云集

Java基础_第一篇

Java特点

重载

Tips

继承

java中对象类型的转型

向上转型

向下转型

多态

抽象类

语法：

接口

语法：

实例：

注意：

实例代码

结果：

接口与继承

Instanceof

使用instanceof来实现这种判断

语法：

示例：

Java类包

类名冲突

类路径

创建包

导入包

final

注意：

另：

示例code:

final方法

相比较与private：

fianl类

注意：

Code:

你可能也喜欢

热评文章

发表评论

标签云集

使用`instanceof`来实现这种判断