1. java数组
- 方式一：
int a[] = {1, 2, 3};，直接声明，无需new
- 方式二：
int b[] = new int[3];，需自己开辟
- 方式三：
int[] c = new int[3];，java数组的规范写法
package clc;
import java.util.Scanner;
public class array {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//方式一
int a[] = {1, 2, 3};
//方式二
int b[] = new int[3];
//方式三
int[] c = new int[3];
for (int i = 0; i < a.length; i++)
{
a[i] = sc.nextInt();
}
for (int i = 0; i < b.length; i++)
{
b[i] = sc.nextInt();
}
for (int i = 0; i < b.length; i++)
{
c[i] = sc.nextInt();
}
for (int i = 0; i < a.length; i++)
{
System.out.println("a="+a[i]);
}
for (int i = 0; i < b.length; i++)
{
System.out.println("b="+b[i]);
}
for (int i = 0; i < c.length; i++)
{
System.out.println("c="+c[i]);
}
}
}
//////////////////////////////////
1
2
3
4
5
6
7
8
9
a=1
a=2
a=3
b=4
b=5
b=6
c=7
c=8
c=9
2. java面向对象
2.1 封装
- 定义：即将所有东西放到一起，然后按照新的形式呈现出来。具体而言就是将方法与字段一起包装到一个单元中，单元以类的形式呈现出来
- 目的：封装是为了将信息隐藏，隐藏对象的实现细节，不能让外部直接访问到类里面的成员变量或者成员方法
- 示例（java版本）
package java封装;
class Student{
int age;
double score;
String name;
void show_tips() {
System.out.println("这个学生信息如下:");
}
void show_msg() {
System.out.println("姓名:"+name+",年龄:"+age+",分数:"+score);
}
}
public class Demo1 {
public static void main(String[] args) {
//实例化一个对象,即给这个对象分配内存空间
Student stu1 = new Student();
stu1.name = "makabaka";
stu1.age = 20;
stu1.score = 99.9;
stu1.show_tips();
stu1.show_msg();
}
}
///////
这个学生信息如下:
姓名:makabaka,年龄:20,分数:99.9
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
struct Student{
int age;
double score;
char name[20];
void (*show_tips)(void);
void (*show_msg)(char *name, int age, double score);
};
void show_tips(void)
{
printf("这个学生信息如下:\n");
}
void show_msg(char *name, int age, double score)
{
printf("姓名：%s", name);
printf(",年龄:%d", age);
printf(",分数：%.2f\n", score);
}
int main(int argc, char *argv[])
{
struct Student stu1;
stu1.age = 20;
stu1.score = 99.9;
strcpy(stu1.name, "makabaka");
stu1.show_tips = show_tips;
stu1.show_msg = show_msg;
stu1.show_tips();
stu1.show_msg(stu1.name, stu1.age, stu1.score);
return 0;
}
//////
这个学生信息如下:
姓名：makabaka,年龄:20,分数：99.90
2.2 java访问修饰符
- Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限
-
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
-
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
-
public : 对所有类可见。使用对象：类、接口、变量、方法
-
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
| 修饰符 |
当前类 |
同一包内 |
子孙类(同一包) |
子孙类(不同包) |
其他包 |
public |
Y |
Y |
Y |
Y |
Y |
protected |
Y |
Y |
Y |
Y/N（说明） |
N |
default |
Y |
Y |
Y |
N |
N |
private |
Y |
N |
N |
N |
N |
package java封装;
class Gay{
private String sex;
void change_sex(String new_sex) {
sex = new_sex;
}
void show_sex() {
System.out.println("性别:"+sex);
}
}
public class permission {
public static void main(String[] args) {
Gay g = new Gay();
//由于sex变量为private类型,故不可以通过类的对象来直接访问该变量
// g.sex = "男";
// g.show_sex();
//由于sex变量为private类型,故不可以通过类的方法(get与set方法)来直接访问该变量
g.change_sex("女");
g.show_sex();
}
}
2.3 setter与getter
- 用于设置或者读取类里面的具有private等属性的变量
package java封装;
class Persion{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class gc_test {
public static void main(String[] args) {
Persion p = new Persion();
p.setAge(20);
System.out.println("age="+p.getAge());
}
}
2.4 UML类图基础
-
+：public
-
-：private
-
#：protected
2.5 构造方法
- 功能：负责对象初始化操作，为对象的属性设置合适的初始值
- 规则：
- 构造方法名称与类名一致
- 构造方法没有返回值，没有返回值不等于返回值为void
- 方法的实现主要是为类的属性变量设置初值
- 构造方法的调用：实例化对象的时候被自动调用，即
new。java保证每个类都有构造方法
- 其他：构造方法可被重载（函数名一样，参数列表不同）
- 示例
class People{
int age;
People(){
System.out.println("调用无参构造方法");
}
People(int new_age){
System.out.println("调用有参构造方法");
age = new_age;
}
}
public class Create_fun {
public static void main(String[] args) {
People p1 = new People(20);
System.out.println("age="+p1.age);
People p2 = new People();
System.out.println("age="+p2.age);
}
}
//////
调用有参构造方法
age=20
调用无参构造方法
age=0
2.6 this关键字
class People{
private String name;
private int age;
public People(String name, int age) {
this.name = name; //this表示将参数name赋值给本类中的name变量
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void tell() {
System.out.println("姓名:"+this.getName()+"\n年龄:"+this.getAge());
}
}
public class test03 {
public static void main(String[] args) {
People p = new People("hanqi", 21);
p.tell();
}
}
- 调用本类中的构造方法，只有加了this(参数列表)才可调用无参构造方法,且this(参数列表)必须在最前面
//要求在下述场景中调用无参构造方法,此时可通过this调用
class Person{
int age;
String name;
public Person(int age, String name) {
this(); //只有加了this()才可调用无参构造方法,且this()必须在最前面!!!!!!!!!!!!
this.age = age;
this.name = name;
System.out.println("调用有参构造方法");
}
public Person() {
System.out.println("调用无参构造方法");
}
}
public class test04 {
public static void main(String[] args) {
Person p = new Person(21, "hanqi");
}
}
///
调用无参构造方法
调用有参构造方法
- 表示当前对象（当前对象的引用），可用来判断两个对象是否来自于同一个对象
class People1{
public void tell() {
System.out.println(this);
}
}
public class test05 {
public static void main(String[] args) {
People1 p = new People1();
p.tell();
System.out.println(p);
}
}
///
com.hanqi.test.People1@15db9742
com.hanqi.test.People1@15db9742
2.7 static关键字
- 用来修饰类的成员或者用于修饰成员变量的类称为类变量（静态变量），类变量可直接通过类名访问，无需实例化类
class Data{
int num_a;
static int num_b;
}
public class static使用 {
public static void main(String[] args) {
Data.num_b = 2; //正确,static变量可直接通过类名访问
Data.num_a = 1; //错误,普通变量不能直接通过类名访问
}
}
- 修饰成员方法称为类方法，类方法可直接调用，无需实例化，例如main方法不用new就可以调用
public class static_test {
public static void main(String[] args) {
System.out.println("1+2="+sum(1, 2));
static_test s = new static_test();
System.out.println("3-2="+s.sub(3, 2));
}
//无需实例化即可调用sum方法
static int sum(int a, int b) {
return a + b;
}
//需要实例化才可调用sub方法
int sub(int a, int b) {
return a - b;
}
}
- 用于修饰语句块称为静态代码块，静态代码块比构造方法先执行且只执行一次，用来对静态成员做初始化
package java封装;
class Data{
int num_a;
static int num_b;
//静态代码块
static {
System.out.println("执行静态代码块");
num_b = 10;
}
//无参构造方法
Data(){
System.out.println("执行构造方法");
num_b = 20;
}
}
public class static_test {
public static void main(String[] args) {
Data d1 = new Data();
System.out.println("num="+Data.num_b);
Data d2 = new Data();
System.out.println("num="+Data.num_b);
}
}
//////
执行静态代码块
执行构造方法
num=20
执行构造方法
num=20
-
静态方法中不能使用this关键字，因为静态方法在类被加载的时候就会被加载，即在对象还没被new之前就会执行，既然对象都还没被new出来，又如何使用this呢？
2.8 java包机制
- 标准java库是由一系列的包组成，包括java.lang，java.util，java.net等
- 标准java包就是层次型包结构，有点像硬盘上文件子目录一样，我们可以使用嵌套层次结构来组织包
- java包是为了更好地规划代码，防止命名冲突与混乱，两个包里面的变量方法可以重名
- 当把类组织起来放进一个包里面的时候，也就给包中的成员赋予了相互访问的权限，也就拥有了该包里面的程序代码
- 声明包：我们可以编写属于我们自己的包，为保证包名字唯一，要求程序员在自己定义包的名字前面加上唯一的前缀。由于互联网上的域名不会重复，故推荐使用公司在互联网上的域名的倒置作为包的唯一前缀，例如
com.baidu.www
- 包的使用：
- 一个类可以使用同一个包中的所有类
- 一个类可以使用其他包中的所有公开类，如何使用呢？
java.util.Date today = new java.util.Date();
- 更简洁通用的方式：使用import语句来导入包（eclipse ctrl+shift+o）
import java.util.Date;
...
Date today = new Date();
- 可使用import特定类，也可以导入整个包。通过在源代码文件的顶部（在打包语句之后）使用import语句来实现
import java.util.*
2.9 继承
- 在java中除了object类之外，所有的类都是子类
- 父类更抽象，子类更具体
- 使用
extend关键字表示继承
- 例子，学生类继承人类
class Persion{
String name;
int age;
void eat() {
System.out.println("人吃饭");
}
void drink() {
System.out.println("人喝水");
}
}
class Student extends Persion{
void goto_school() {
System.out.println("学生上学");
}
}
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
s.eat();
s.drink();
}
}
3.0 super关键字
- super与this关键字的特点类似，super代表的是父类对象的引用
- 当子父类的成员出现同名的时候，可以通过super关键字区分
class Persion{
void eat(){
System.out.println("父类eat");
}
}
class Student extends Persion{
void eat(){
//通过super关键字调用父类的方法
super.eat();
System.out.println("子类eat");
}
}
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
s.eat();
}
}
//////
父类eat
子类eat
- 子类构造方法中，通过super关键字调用父类的构造方法进行初始化
package jicheng.hq.java;
class Persion{
String name;
int age;
//父类构造方法
Persion(String name, int age){
this.name = name;
this.age = age;
System.out.println("父类构造方法被调用");
}
}
class Student extends Persion{
void goto_school() {
System.out.println("学生上学");
}
Student(String name, int age){
//子类构造方法通过super关键字调用父类构造方法进行初始化
super(name, age);
System.out.println("子类构造方法被调用");
}
}
public class Test01 {
public static void main(String[] args) {
Student s = new Student("hq", 25);
System.out.println("name="+s.name+",age="+s.age);
}
}
//////
父类构造方法被调用
子类构造方法被调用
name=hq,age=25
- 当构造一个子类对象的时候一定会先调用父类的构造方法来构造父类的对象。调用父类的构造方法的语句必须是子类构造方法中的第一条语句
3.1 继承之私有权限
-
父类的私有属性与方法不能被子类所继承，子类只能通过
super关键字来设置父类的私有属性
class Persion{
//父类私有变量
private int age;
//父类构造方法
Persion(int age){
this.age = age;
}
//打印父类私有属性的方法
void print_info() {
System.out.println("age="+age);
}
}
class Student extends Persion{
//子类构造方法,用于设置父类私有属性
Student(int age){
super(age);
}
}
public class Test01 {
public static void main(String[] args) {
Student s = new Student(20);
s.print_info();
}
}
//////
age=20
3.2 方法重写
- 指的是子类可以根据需要对从父类继承过来的方法进行改写
- 重写需要注意：
- 重写方法必须与被重写的方法具有相同的方法名称、参数列表与返回值
package jicheng.hq.java;
class Persion{
int age;
//父类方法
void print_info() {
System.out.println("父类age="+age);
}
}
class Student extends Persion{
//子类重写的父类方法
void print_info() {
//子类调用父类被重写的方法
super.print_info();
System.out.println("子类age="+age);
}
}
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
s.age = 20;
s.print_info();
}
}
//////
父类age=20
子类age=20
- 重写方法不能比被重写的方法有更严格的权限
- 父类里面的私有方法不能被重写
- 在子类重写的方法中可通过super关键字去调用父类中被重写的方法，
super.函数名
3.3 object类
- object类是所有子类的老祖宗
- 其内部有一些默认方法，例如
toString()，equals()，hashcode()，clone，getClass()，finalize()等
-
toString()方法默认打印的是类的地址，然而toString的方法功能是转为字符串，所以需要重写
//重写前
class Persion{
String name;
}
public class Test01 {
public static void main(String[] args) {
Persion p = new Persion();
p.name = "hq";
System.out.println(p.toString());
}
}
//////
jicheng.hq.java.Persion@15db9742
//重写后
class Persion{
String name;
//重写toString方法
public String toString() {
return name;
}
}
public class Test01 {
public static void main(String[] args) {
Persion p = new Persion();
p.name = "hq";
System.out.println(p.toString());
}
}
//////
hq
class Persion{
String name;
//重写equals方法
public boolean equals(Object obj) {
if(obj == null)
{
return false;
}
else
{
if(obj instanceof Persion)
{
//强制转换为Persion类
Persion p = (Persion)obj;
if(p.name == this.name)
{
return true;
}
}
}
return false;
}
}
public class Test01 {
public static void main(String[] args) {
Persion p1 = new Persion();
Persion p2 = new Persion();
p1.name = "hq";
p2.name = "hq";
System.out.println(p1.equals(p2));
}
}
//////
true
3.4 抽象类
- 定义：java中可以定义没有方法体的方法，该方法由子类来具体实现。含有抽象方法的类称为抽象类
- 抽象方法特点：
- 只有方法头没有方法体
- 使用
abstract关键字修饰
- 抽象方法代表一种不确定的操作或者行为
- 抽象方法不能被调用
- 抽象方法只能放在抽象类里面
abstract class Demo1{
abstract public void print_info();
}
- 有抽象方法的类称为抽象类
- 抽象类使用
abstract修饰
- 抽象类代表一种抽象的对象类型
- 抽象类不能实例化
- 抽象类里面可有具体方法，也可以没有抽象方法
-
抽象类不能被实例化，即不能被new，一般抽象类会被其子类继承，且子类需要实现父类里面的抽象方法
//抽象类
abstract class Demo1{
//抽象方法
abstract public void print_info();
}
//继承抽象类
class Demo2 extends Demo1{
//实现抽象方法
public void print_info() {
System.out.println("makabaka");
}
}
public class Test01 {
public static void main(String[] args) {
Demo2 d = new Demo2();
d.print_info();
}
}
//////
makabaka
3.5 模板方法模式
- 定义：一个模板方法用一些抽象的操作定义一个算法，而子类将重定义这些操作以提供具体行为
- 意图：定义了一个操作中的一个算法框架，把一些步骤推迟到子类去实现。模板方法模式让子类不需要改变算法结构
- 举个例子，假设有一系列的智能家居控制流程，我们可以将其控制流程进行抽象，之后换用不同平台的时候再去具体实现每个具体步骤即可
//抽象类
abstract class Control{
abstract void init_uart();
abstract void get_command();
abstract void open_curse();
abstract void open_led();
abstract void open_tv();
public void work() {
init_uart();
get_command();
open_curse();
open_led();
open_tv();
}
}
class C51 extends Control{
void init_uart() {
System.out.println("C51 init uart");
}
void get_command() {
System.out.println("C51 get command");
}
void open_curse() {
System.out.println("C51 open curse");
}
void open_led() {
System.out.println("C51 open LED");
}
void open_tv() {
System.out.println("C51 open TV");
}
}
class Stm32 extends Control{
void init_uart() {
System.out.println("Stm32 init uart");
}
void get_command() {
System.out.println("Stm32 get command");
}
void open_curse() {
System.out.println("Stm32 open curse");
}
void open_led() {
System.out.println("Stm32 open LED");
}
void open_tv() {
System.out.println("Stm32 open TV");
}
}
public class Test01 {
public static void main(String[] args) {
C51 c51 = new C51();
c51.work();
Stm32 stm32 = new Stm32();
stm32.work();
}
}
//////
C51 init uart
C51 get command
C51 open curse
C51 open LED
C51 open TV
Stm32 init uart
Stm32 get command
Stm32 open curse
Stm32 open LED
Stm32 open TV
3.6 接口
interface 接口名{
//公有静态常量、抽象方法
}
- 接口中只能够存放静态常量与抽象方法
- java接口是对功能的拓展
- 通过实现接口，java类可以实现多实现
- 一个类可以同时继承一个父类并实现多个接口
- 接口与接口之间可以使用extends实现继承
- 继承就有一些亲属关系，而接口则没有亲属关系，更多的则是更在乎不同类里面的行为关系
- 例子
interface Behavior{
abstract void eat();
abstract void drink();
}
class People implements Behavior{
public void eat() {
System.out.println("人吃");
}
public void drink() {
System.out.println("人喝");
}
}
class Dog{
public void eat() {
System.out.println("狗吃");
}
public void drink() {
System.out.println("狗喝");
}
}
public class Test01 {
public static void main(String[] args) {
new People().eat();
new Dog().eat();
}
}
//////
人吃
狗吃
3.7 内部类
- 内部类可以很好地实现隐藏，可使用
protected、private等修饰符
- 内部类可以直接访问外部类的所有成员，包括私有成员
- 外部类不能直接直接访问内部类的成员，必须首先建立内部类的对象之后才能访问
- 实例化内部类，
外部类名.内部类名 内部类实例名实例 = 外部类实例名.new 内部类名(参数)
package 抽象;
//定义外部类
class Outer{
int data;
void print_msg() {
System.out.println("外部类打印");
}
//定义内部类
class Inner{
int data;
void print_msg() {
System.out.println("内部类打印");
}
}
}
public class Test01 {
public static void main(String[] args) {
//实例化外部类
Outer o = new Outer();
//实例化内部类
Outer.Inner i = o.new Inner();
i.print_msg();
}
}
//////
内部类打印
- 内部类调用外部类方法，
外部类名.this.成员方法（变量）
package 抽象;
//定义外部类
class Outer{
int data;
void print_msg() {
System.out.println("外部类打印");
}
//定义内部类
class Inner{
int data;
void print_msg() {
System.out.println("内部类打印");
//内部类调用外部类方法
Outer.this.print_msg();
}
}
}
public class Test01 {
public static void main(String[] args) {
//实例化外部类
Outer o = new Outer();
//实例化内部类
Outer.Inner i = o.new Inner();
i.print_msg();
}
}
//////
内部类打印
外部类打印
3.8 匿名内部类
- 匿名内部类是没有名称的内部类，没办法引用他们。必须在创建时候作为new语句的一部分来声明并创建他们的实例
- 匿名内部类必须继承一个类（抽象、非抽象的均可）或者实现一个接口，如果所有父类（或者父类接口）是抽象类，则匿名内部类必须实现其所有抽象方法
- 语法：这种形式的new语句声明一个新的匿名类，它对一个给的的类进行扩展，或者实现一个给的的接口，并同时创建该匿名类的一个新实例
new interface/superclass(){类体}
abstract class Test{
abstract void print_msg();
}
public class Test01 {
public static void main(String[] args) {
//创建了一个匿名内部类并生成了一个实例
new Test() {
void print_msg() {
System.out.println("匿名内部类调用方式1");
}
}.print_msg();
Test t1 = new Test() {
void print_msg() {
System.out.println("匿名内部类调用方式2");
}
};
t1.print_msg();
}
}
//////
匿名内部类调用方式1
匿名内部类调用方式2
