JAVA概念总结

最新推荐文章于 2022-07-14 17:36:18 发布
最新推荐文章于 2022-07-14 17:36:18 发布
阅读量1.2k 收藏 5
点赞数
分类专栏： Java 文章标签： java 总结 接口 多态 抽象类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45866407/article/details/117573675
版权

本文主要记录一些本人在Java学习中的感觉比较重要的概念(更新中~)

目录

方法

方法类似于C语言中的‘函数’这一概念。

static

public class Test 
{
	public static void main(String[] args) 
	{
		Person per1 = new Person("John",18,"中国");
		Person per2 = new Person("Lucy",26);
		Person per3 = new Person("fly-beep",16);
		
		per1.show();
		per2.show();
		per3.show();
		
		System.out.println("------------------------");
		
		per3.country = "中国台湾";
		per1.show();
		per2.show();
		per3.show();
 	}
}

class Person
{
	public String name;
	public int age;
	public static String country;
	
	public Person(String name,int age) 
	{
		this.name = name;
		this.age = age;
	}
	
	public Person(String name,int age,String country) 
	{
		this(name, age);
		this.country = country;
	}
	
	public void show()
	{
		System.out.println(this.name + " : " +  this.age + " from " + this.country);
	}
}

输出：

John : 18 from 中国
Lucy : 26 from 中国
fly-beep : 16 from 中国
------------------------
John : 18 from 中国台湾
Lucy : 26 from 中国台湾
fly-beep : 16 from 中国台湾

static特点：

A.随着类加载而加载（main方法）
B.优于对象存在
C.被类中所有对象共享
D.可以通过类名调用（推荐使用）

public class Test 
{
	public static void main(String[] args) 
	{
		System.out.println(Person.num);
 	}
}

class Person
{
	public static int num = 10;
}

输出：

10

static注意事项：
A.在静态方法中没有this关键字
B.静态方法只能访问静态成员变量和静态成员方法，非静态方法随意

构造方法

public class Test {
    public static void main(String[] args) {
		Students stu = new Students("fly-beep",001);
		System.out.println("Name : " + stu.getName() + " id : " + stu.getId());
    }
}

class Students
{
	private String name;
	private int id;
	
	public Students()
	{
		
	}
	
	public Students(String name,int id)
	{
		this.name = name;
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
}

里面的

public Students()
	{
		
	}
	
	public Students(String name,int id)
	{
		this.name = name;
		this.id = id;
	}

都是构造方法，构造方法可以带参数也可以不带参数。Java默认会给你一个不带参数的构造函数，但如果你自己写了构造函数，Java就不会再为你提供无参构造函数。

函数重载(Overload)

函数重载就是在一个类里面定义好多个同名的方法，但是这些方法的参数不一样，（就是参数类型或数目不一样，其他一不一样无所谓）。

public class Test {
    public static void main(String[] args) {
    	Students stu0 = new Students();
		System.out.println("Name : " + stu0.getName() + " id : " + stu0.getId());
    	
		Students stu1 = new Students("fly-beep");
		System.out.println("Name : " + stu1.getName() + " id : " + stu1.getId());
		
		Students stu2 = new Students("fly-beep",001);
		System.out.println("Name : " + stu2.getName() + " id : " + stu2.getId());
    }
}

class Students
{
	private String name;
	private int id;
	
	public Students()
	{
		
	}
	
	public Students(String name)
	{
		this.name = name;
	}
	
	public Students(String name,int id)
	{
		this.name = name;
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
}

函数重写(Override)

函数重写是在子类里面把父类的方法重新再写一遍。

方法重写需要注意的点：

  • 父类私有方法不能重写
  • 子类重写父类方法，访问权限不能降低（最好保持一致）
  • 父类静态方法子类也必须通过静态方法重写（必须两边都有static，缺一个都不行）

访问权限：

public > protected > default > private

（若不写即为default）

public class Test {
    public static void main(String[] args) {
    	Cat cat = new Cat();
    	cat.drink();
    	cat.eat();
    	cat.sleep();
    }
}

class Animal
{
	public void eat() 
	{
		System.out.println("eat");
	}
	
	public void sleep() 
	{
		System.out.println("sleep");
	}
	
	public static void drink() 
	{
		System.out.println("drink");
	}
}

class Cat extends Animal
{
	@Override
	public void eat() 
	{
		System.out.println("eat rabbit");
	}
	
	@Override
	public void sleep() 
	{
		System.out.println("sleep well");
	}
	
	public static void drink() 
	{
		System.out.println("drink water");
	}
}

this&super

this--->当前类对象引用
super--->父类的对象引用

主要可以分为以下三种情况：

  • 1.成员变量
public class Test 
{
	public static void main(String[] args) 
	{
		Child child = new Child();
		child.show();
	}
}

class Father
{
	public int num = 30;
}

class Child extends Father
{
	public int num = 20;
	
	public void show()
	{
		int num = 10;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}

输出如下：

10
20
30
  • 2.构造方法
public class Test 
{
	public static void main(String[] args) 
	{
		Child child = new Child();
	}
}

class Father
{
	public Father() 
	{
		System.out.println("Father的无参构造函数");
	}
}

class Child extends Father
{
	public Child() 
	{
		System.out.println("Child的无参构造函数");
	}
}

输出：

Father的无参构造函数
Child的无参构造函数

子类所有的构造方法（包括有参，无参）都会默认采用父类的构造方法
子类的构造方法第一句默认都是

super();

子类至少有一个访问父类的构造方法，否则父类数据就没有初始化

this();
super();

上面的两句一定要放在构造方法第一句

  • 3.成员方法

从子类里面调用方法：

– 先从子类中找
– 再从父类中找
– 一直找不到就报错

public class Test 
{
	public static void main(String[] args) 
	{
		Child child = new Child();
		child.show();
		
		Father father = new Father();
		father.show();
	}
}

class Father
{
	public void show() 
	{
		System.out.println("Father show");
	}
}

class Child extends Father
{
	public void show() 
	{
		System.out.println("Child show");
	}
}

输出：

Child show
Father show

final

  • final修饰类

该类不能被继承

  • final修饰方法

该方法不能被重写

  • final修饰变量

该变量不能被赋值，该变量其实是常量（自定义常量）

public class Test 
{
	public static void main(String[] args) 
	{
		int x = 10;
		x = 100;
		System.out.println(x);
		
		System.out.println("--------------------");
		
		final int y = 10;
		//y = 100   ERROR
		System.out.println(y);
		
		System.out.println("--------------------");
		
		Student stu = new Student();
		System.out.println(stu.age);
		stu.age = 100;
		System.out.println(stu.age);
		
		System.out.println("--------------------");
		
		final Student stu1 = new Student();
		System.out.println(stu1.age);
		stu1.age = 100;
		System.out.println(stu1.age);
		
		
		//stu1 = new Student();  	ERROR 这改变了地址
	}
}

class Student
{
	int age = 10;
}

输出：

100
--------------------
10
--------------------
10
100
--------------------
10
100

注意
final修饰引用类型，引用类型的地址不能变，但是值是可以变的 !

多态

某一个事物在不同时间表现出不同的状态。

多态前提：
A.要有继承关系
B.要有方法重写
C.要有父类

多态中成员访问特点

重要

A.成员变量
编译看左边，运行看左边

B.构造方法
创建子类对象时，访问父类的构造方法，要对父类数据进行初始化

C.成员方法
编译看左边，运行看右边

D.静态方法
编译看左边，运行看左边

public class Test 
{
	public static void main(String[] args) 
	{
		Father father =new Child();
		System.out.println(father.num);   //运行看左边
		
		father.show();  //运行看右边
		
		father.show1();  //运行看左边
	}
}

class Father
{
	public int num = 10;
	
	public void show() 
	{
		System.out.println("Father is handsome");
	}

	public static void show1() 
	{
		System.out.println("static Father");	
	}
}

class Child extends Father
{
	public int num = 100;
	
	public void show() 
	{
		System.out.println("Child is very handsome");
	}
	
	public static void show1() 
	{
		System.out.println("static Child");	
	}
}

输出：

10
Child is very handsome
static Father

但是多态有一个问题，不能使用子类独有的方法，于是我们就有了向下转型的概念：

public class Test 
{
	public static void main(String[] args) 
	{
		Father father =new Child();
		
		//father.show1();  ERROR
		Child child = (Child)father;
		child.show1();
 	}
}

class Father
{

}

class Child extends Father
{
	public void show1() 
	{
		System.out.println("Father,come to use me");
	}
}

输出：

Father,come to use me

有向下转型就有向上转型：

public class Test 
{
	public static void main(String[] args) 
	{
		Father father = new Child();
		//father.show1();  ERROR
		Child child = (Child)father;
		child.show1();
 	}
}

class Father
{
	
}

class Child extends Father
{
	public void show1() 
	{
		System.out.println("Father,come to use me");
	}
}

输出：

Father,come to use me

抽象类

抽象类的子类：

A.如果不想抽象抽象方法，则子类是一个抽象类

B.重写所有抽象方法，子类是一个具体的类

对于抽象类还是分以下三种情况进行讨论：

  • 成员变量

常量/变量

  • 构造函数
    可以有构造函数，用于子类初始化变量

  • 成员方法
    – 抽象方法：强制子类做
    – 非抽象方法：子类继承

abstract不能与以下关键字共存：
private冲突，不能重写
final冲突，不能重写
static没有意义，static要有方法体，而abstract没有

接口

接口就是功能的扩展，并没有方法的实现

接口要使用多态的方式实例化

接口的子类可以是抽象类（但意义不大）

接口的方法一般都是具体类，但是要重写接口中所有的抽象方法

接口中注意项：

A.成员变量

  • 只能是常量，并且是静态
  • 默认修饰符：public static final

B.构造方法

  • 接口没有构造方法

C.成员方法

  • 只能是抽象方法
  • 默认修饰符：public abstract

类和接口关系：

A.类与类

  • 继承关系，只能单继承，但可以多层继承

B.接口与类

  • 实现关系，可以单实现，也可以多实现
  • 可以一个类实现多个接口

C.接口与接口

  • 继承关系，可以单继承，也可以多继承

接口和抽象类区别：

A.成员区别：

  • 抽象类
    – 成员变量：可以变量，可以常量
    – 构造方法：有
    – 成员方法：可以抽象，可以非抽象

  • 接口
    – 成员变量：只能是常量
    – 成员方法：只能是抽象

B.关系区别

同上“类和接口关系”：

C.设计理念区别

  • 抽象类 被继承体现的是 ： “is a”的关系。抽象类中定义的是该继承体系的共性功能
  • 接口 被实现体现的是 ： “like a”的关系。接口中定义的是该继承体系的扩展功能

泛型

  • 类
public class Test<T>
{

}
  • 方法
public <T> void Eat(T food)
{
	
}
  • 接口
interface inter<T>
{
	
}

通配符：

import java.util.ArrayList;
import java.util.Collection;

public class Test
{
	public static void main(String[] args) 
	{
		//泛型如果明确写，前后必须一致
		Collection<?> collection1 = new ArrayList<Object>();
		Collection<?> collection2 = new ArrayList<Animal>();
		Collection<?> collection3= new ArrayList<Dog>();
		Collection<?> collection4 = new ArrayList<Cat>();
		
		//extends E : 向下限定，E及其子类
		//Collection<? extends Animal> collection5 = new ArrayList<Object>();  ERROR
		Collection<? extends Animal> collection6 = new ArrayList<Animal>();
		Collection<? extends Animal> collection7= new ArrayList<Dog>();
		Collection<? extends Animal> collection8 = new ArrayList<Cat>();
		
		//？extends E : 向上限定，E及其父类
		Collection<? super Animal> collection9 = new ArrayList<Object>();
		Collection<? super Animal> collection10 = new ArrayList<Animal>();
		//Collection<? super Animal> collection11 = new ArrayList<Dog>();  ERROR
		//Collection<? super Animal> collection12 = new ArrayList<Cat>();  ERROR
 	}
	
}

class Animal
{
	
}

class Dog extends Animal
{
	
}

class Cat extends Animal
{
	
}

可变参数

当不知道到底要传入几个参数时，可以使用可变参数的形式来传参：

public class Test
{
	public static void main(String[] args) 
	{
		System.out.println("sum : " + sum(10,12,3,6,3));
		System.out.println("sum : " + sum(10,12,3));
		System.out.println("sum : " + sum(10,12));
		System.out.println("sum : " + sum(10,12,3,6));
	}
	
	//相当于传进去一个数组
	public static int sum(int... s)
	{
		int sum = 0;
		
		for(int a : s)
		{
			sum += a;
		}
		return sum;
	}
}

public class Test
{
	public static void main(String[] args) 
	{
		String[] array = {"hello","world"};
		
		//asList : 将数组转为列表
		List<String> list = Arrays.asList(array);
		
		for (String string : list) 
		{
			System.out.println(string);
		}
	}
}
桂花鱼_
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java基础知识总结（超详细整理）
龙源IT 的博客
07-17 25万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
Java基础 - 计算机概述、Java语言概述、关键字，java面试知识点总结
最新发布
m0_60567796的博客
04-01 701
1.Java语言发展史：詹姆斯·高斯林（James Gosling），1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。Java 语言是面向对象的、解释执行的网络编程语言。Java 语言具有可移植性，是与平台无关的编程语言。Java 语言可对内存垃圾自动收集。Java 语言编写的程序虽然是“一次编译，到处运行”，但必须要java的运行环境。2.Java语言平台。
Java简明教程-基本语法上
weixin_41603934的博客
03-15 788
基本语法上认识java变量常量数据类型String计算字符串长度字符串比较字符串连接字符串常用提取方法 认识java JVM 叫 Java 虚拟机，它也是整个 Java 技术的核心。Java 语言的跨平台就多亏了 JVM。 JDK 叫 Java 开发工具包，没有 JDK 就没有办法进行 Java 程序的开发。 JRE 叫 Java 运行环境，如果我们需要运行一个 Java 程序，就得安装 JRE。 JDK、JRE 和 JVM 之间的关系： 变量 在 Java 中，变量需要先声明 (declare) 才能
01_java基础
温故。的博客
03-13 211
day01_Java基础 一、课程目标 1. 【了解】Java语言发展史 2. 【理解】Java语言平台版本 3. 【理解】Java语言特点 4. 【理解】JRE与JDK 5. 【掌握】Java开发环境搭建 6. 【掌握】第一个Java程序 7. 【掌握】注释 8. 【理解】关键字/标识符 二、Java语言概述 2.1 Java语言发展史 Java之父：詹姆斯·高斯林（James Gosling） 1977年获得了加拿大卡尔加里大学计算机科学学士学位
JAVA基础知识点总结
热门推荐
sen_sen97的博客
07-11 1万+
Java 是一门面向对象的编程语言。 语言特点：面向对象，平台无关性，支持多线程，编译与解释并存JVM：Java Virtual Machine，Java 虚拟机。 JRE： Java 运⾏时环境。 JDK: Java Development Kit，它是功能⻬全的 Java SDK。 JDK 包含 JRE，JRE 包含 JVM。Java 程序从源代码到运行主要有三步： 编译：将我们的代码（.java）编译成虚拟机可以识别理解的字节码(.class) 解释：虚拟机执行 Java 字节码，将字节码翻译成机器能
java概念总结
12-03
总结了一下java基础的一些概念,可能不太全面,你们也可以补充一下
JAVA概念总结 代码总结 最全 最新
04-13
详细分类分知识点记录，思路清晰明确易于理解
java基本概念总结.pdf
10-03
java基本概念总结.pdf
Java多线程编程总结
01-31
下面的内容是很早之前写的，内容不够充实，而且是基于Java1.4的内容，Java5之后，线程并发部分扩展了相当多的内容，因此建议大家看上面的系列文章的内容，与时俱进，跟上Java发展的步伐。要认识多线程就要从操作系统...
JAVA模式与设计概念总结
11-06
JAVA模式与设计概念总结，绝对详细；JAVA模式与设计概念总结，绝对详细；
Java基础知识总结 （绝对经典）
11-06
写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。   学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。
Java——概念整理
qq_44371305的博客
02-28 603
1. JDK JRE JVM(三大任务) JDK（ Java Development Kit） ： java 开发工具包 JVM 虚拟机的三大任务： 1、加载代码(.class)、 2 校验代码(头信息、版本)、 3 执行代码 2. Java常用命令:java javac javac ： 将源程序编译成可执行程序 java：运行.class可执行程序 执行过程： # 编译文件 C:\Users\jack\Desktop\XZ_264_JAVA_01\code\01>javac -encoding ut
了解Java基本概念，这一篇就够了
故渔者歌曰
07-14 1166
了解Java基本概念，这一篇就够了。JAVA、JDK、JRE、JVM等相关概念
Java基础知识面试题
qq_664820570
03-24 5212
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上用最有效率的方法计算
Java语言概述
qq_57181249的博客
05-08 2661
1，java语言概述 1，java语言特性 ​ 类C语言发展和衍生的产物，摒弃了C语言的指针，是纯粹的面向对象语言。增加了垃圾回收器功能。 易学的，面向对象的，健壮的，分布式的，安全的，多线程的，平台无关，无指针，高性能的，自动收集内存 2，java程序的运行机制及运行过程 1.特点一：面向对象 基本概念：类，对象 三大特点：封装，继承，多态 2.特点二：健壮性 吸收了C/C++语言的优点，去掉了其影响程序健壮性的部分,(指针，内存的申请与释放等)，提供了一个相对安全的内存管理与访问机制 3.跨平台性
java 概念_JAVA概念总结(一)
weixin_32518073的博客
02-12 106
注意: 学习Java,一定要学会查阅 API 文档Java概念总结(二)API很重要.jpg参数列表: 参数类型+参数个数+参数顺序方法签名: 方法名称+方法参数列表注意：在同一个类中，方法签名是唯一的方法体: 方法的{}中的代码，表示具体完成该功能的代码返回值: 在方法内部：使用return关键字功能1:给调用者返回一个结果功能2:结束一个方法实际参数: 调用者在调用某一方法...
java最全的概念与知识点总结
qq_33366098的博客
05-06 7359
java概念知识点总结   一、基础语法 java内存模型和内存区域以及执行过程理解 特例： 基本类型（八大基本类型(boolean、char、byte、short、int、long、float、double) 1） 因为对于一些小的、简单的变量，在new中创建对象往往不是很有效，于是设置了基本类型 2） java中所有不带小数点的类型都默认是int类型，带小数点的默认类型为doubl...
java基本概念总结
m0_65251054的博客
04-20 2688
java总结
分金块问题（Java）实验总结
03-25
本次实验中，我学习了分金块问题的算法和Java语言的对象概念。 在实现算法时，我首先采用了分治算法，将问题不断分解为规模较小的子问题并递归求解，最终合并得到整个问题的解。此外，我还尝试了动态规划的算法，设计了一个二维数组作为状态转移表，并通过填充和利用状态转移方程来求解问题的最优解。 在实现Java的面向对象编程时，我首先设计了一个金块类，用于存储每个金块的大小和价值。接着，我设计了一个金块列表类，用于存储多个金块对象，并通过该类的一些方法来实现对金块列表的操作，如添加、删除、查找等。最后，我在主函数中利用金块列表类来组织金块，调用算法求解分金块问题。 通过本次实验，我进一步掌握了算法和面向对象编程的知识，加深了对Java语言的理解和应用能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值