Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

$ hexo new "My New Post"

More info: Writing

Run server

$ hexo server

More info: Server

Generate static files

$ hexo generate

More info: Generating

Deploy to remote sites

$ hexo deploy

More info: Deployment

匿名函数的注意点及使用

*例 简单概念

public class Demo_Anonymous {

    public static void main(String[] args) {
        Person one = new Person();
        one.name = "张三";
        one.showName();

        System.out.println("=====================");

        new Person().name="lisa";
        new Person().showName();  // 匿名对象只能调用一次  第二次使用则为创新了一个新的匿名对象
    }

}
    class Person{
        String name;

        public void showName() {
            System.out.println(name);
        }

    }

• 匿名对象作为方法的参数列表

import java.util.Scanner;

public class Demo_06 {
public static void main(String[] args) {


     // 匿名对象的方法
//    int num = new Scanner(System.in).nextInt();
//    
//    System.out.println("输出的数字： "+ num);

    // 匿名对象 作为方法的参数列表
    Anonymous_ways(new Scanner(System.in));
}

    public static void Anonymous_ways(Scanner sc) {
        int num = sc.nextInt();
        System.out.println("输出的数字是： " + num);
    }
}

• 匿名方法作为 方法的返回值

import java.util.Scanner;

public class Deom {
public static void main(String[] args) {
    // 匿名对象作为方法的返回值


    Scanner  sc = methodReturn();
    int num = sc.nextInt();
    System.out.println("输出的数是： " + num);

    //System.out.println(sc.nextInt());     也可



}
    public static Scanner methodReturn() {
        return new Scanner(System.in);

    }

}

1.0 方法

• 方法的使用是为了增加代码的重复利用性

1. 方法在Java中相当于一种机制：

–某个功能只需要写一遍
–在使用这个功能时，只需传入相应的数据
–可以完成某个特定的功能，可以重复利用

• 例子：a+b=c 这个功能只需写一遍

  public class show_function{ // 类体 public static void main(String[] args) { show_function.sumLnt(10,20); show_function.sumLnt(99,20); show_function.sumLnt(200,901); } public static void sumLnt(int a,int b){ int c= a + b; System.out.println(a + " + " + b " = " + c); } }

注意：

1. 方法内不能再写方法
2. 类体内可以定义多个方法

Scanner方法

• 和用户交互的方法

  // 创建一个扫描器对象，用于接收键盘数据 Scanner sc = new Scanner(System.in); // 判断用户有没有输入字符串 if(sc.hasNextIn()){ int a = sc.nextInt(); System.out.print(a); } // 属于i/o流 使用完要关闭 sc.close();

• next() 不能得到带有空格的字符串

• next Line()

  1. 以Enter为结束符：也就是说方法返回的是输入回车之前的所有字符
  2. 可以获取空白

关于Java中参数列表

2021.4.8

public class Demo_arrylist {

    public static void main(String[] args) {

        Demo demo = new Demo();
        demo.show("小米");
    }
}

    class Demo{
        String name= "华为";
        public void  show(String name) {

            System.out.println(name+ " 的友商是  "+ this.name );
        }
    }

• 在 public void show(String name) {} 中加入参数列表 string name 相当于形参，在调用show（）方法的时候 需要赋值
• 在show（）方法中调用 demo类的成员变量 可以用this关键字

自己的误解：

• 以为参数列表只是标指 方法中运用的变量
• 实质上也可以看作一个对象 万物皆对象

认知不停 待更新见解…….

构造方法的三个特点：

1.构造方法的名称必须与类的名称相同
2.构造方法的前面没有返还类型 ： public run（）{}
3.如果你没有在类中定义构造方法，那么在编译阶段，编译器会自动给出一个构造方法，也就是说，编译器会在编译阶段在字节码文件中补充添加一个构造方法，此构造方法是没有参数的。

教科书上一般定义为：构造方法是为了创建一个对象 晦涩难懂

另一种简单的的说法： 初始化对象的内部状态 就是说给对象的各个属性赋初值

范例

public class test1 
{   

    public static void main(String[] args) {
        Student p1 =new Student(18,"jack");
        Student p2 =new Student(19,"jack");
        p1.printlnof();
        p2.getAge();
        p2.printlnof();
    }
}

    class Student{
        private int age;
        private String name;
            public Student(int age,String name) {
                this.age=age;
                this.name=name;
            }
            public void printlnof() {
                System.out.println("age: "+age+" name: "+name);
            }
            public void getAge() {
                int s=10;
                age+=s;
            }
    }

// 所谓 构造方法就是 对类的内部进行初始化

效果展示：

这是一级标题

这是二级标题

这是三级标题

这是四级标题

这是五级标题

这是六级标题

这是加粗的文字
这是倾斜的文字

这是斜体加粗的文字
这是加删除线的文字

这是引用的内容

分割线

添加图片的方法：

添加超链接：
简书
百度

无序列表
语法：
用 - + * 任何一种都可以

• 列表内容

• 列表内容

• 列表内容
  注意：- + * 跟内容之间都要有一个空格

有序列表
语法：
数字加点

1. 列表内容
2. 列表内容
3. 列表内容
   注意：序号跟内容之间要有空格

代码处理：
语法：
单行代码：代码之间分别用一个反引号包起来
代码内容

代码块：代码之间分别用三个反引号包起来，且两边的反引号单独占一行
() 代码... 代码... 代码... ()

语法示例：

# 这是一级标题  
## 这是二级标题
### 这是三级标题
#### 这是四级标题
##### 这是五级标题
###### 这是六级标题

**这是加粗的文字**   
*这是倾斜的文字*   

***这是斜体加粗的文字***   
~~这是加删除线的文字~~   
>这是引用的内容  

分割线
---
----
***
*****   
添加图片的方法：   
![元素](https://s1.ax1x.com/2020/06/21/N14qQs.png)   

添加超链接：  
[简书](http://jianshu.com)   
[百度](http://baidu.com)   

无序列表   
语法：
   用 - + * 任何一种都可以   
- 列表内容
+ 列表内容
* 列表内容   
注意：- + * 跟内容之间都要有一个空格   

有序列表   
语法：
数字加点   
1. 列表内容
2. 列表内容
3. 列表内容   
注意：序号跟内容之间要有空格   

代码处理：   
语法：
单行代码：代码之间分别用一个反引号包起来   
 `代码内容`   

 代码块：代码之间分别用三个反引号包起来，且两边的反引号单独占一行   
(```)
  代码...
  代码...
  代码...   
(```)   

转移博客 传送门

csdn 传送门

因为笔记越写越多经常忘记上传 也没买个人域名 还是csdn快捷些 虽然有些小广告 无伤大雅 嘿嘿

变量 常量 作用域

• 注意：
  1. 每个变量都有类型，类型可以是基本类型也可以引用类型
  2. 变量必须先声明后使用

• 变量作用域

  public class Variable{ static int allClicks = 0; // 类变量 String str = 'hello'; // 实例变量 public void method(){ int i = o; // 局部变量 } }

• 类变量

  加了static

  1. 在类里面，且从属于类，随着类的消失而消失

• 常量

  final double PI = 3.14; static final double PI = 3.14;

函数基础回顾

例:

• 定义函数

• 以下是 max() 函数的源代码。该函数有两个参数 num1 和 num2，会返回这两个数中较大的那个数：
• 函数定义提供了函数的实际主体

// 函数返回两个数中较大的那个数
 
int max(int num1, int num2) 
{
   // 局部变量声明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

• 函数声明
  ：函数声明告诉编译器函数的名称、返回类型和参数

int max(int num1, int num2);

• 在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明:

int max(int, int);

• // 一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

• 调用函数
  //一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

#include <iostream>
using namespace std;
 
// 函数声明
int max(int num1, int num2);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   int ret;
 
   // 调用函数来获取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
 
   return 0;
}
 
// 函数返回两个数中较大的那个数
int max(int num1, int num2) 
{
   // 局部变量声明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

// 结果

Max value is ：200

Lambda 函数

• 定义一个可以输出字符串的lambda表达式，表达式一般都是从方括号[]开始，然后结束于花括号{}，花括号里面就像定义函数那样，包含了lamdba表达式体:

// 定义简单的lambda表达式
auto basicLambda = [] { cout << "Hello, world!" << endl; };

// 调用
basicLambda();
// 输出：Hello, world!

• 如果需要参数，那么就要像函数那样，放在圆括号里面，如果有返回值，返回类型要放在->后面，即拖尾返回类型，当然你也可以忽略返回类型，lambda会帮你自动推断出返回类型

// 指明返回类型
auto add = [](int a, int b) -> int { return a + b; };

// 自动推断返回类型
auto multiply = [](int a, int b) { return a * b; };
int sum = add(2, 5);   // 输出：7
int product = multiply(2, 5);  // 输出：10

抽象类和接口

• 用 abstract 修饰的类
• 抽象类中可以没有抽象方法但是一定要声明为抽象类
• 抽象类不可以用new 关键字创建对象，它是用来被子类继承的
• 抽象方法，只有方法的声明没有方法的实现，它是用来让子类实现的
• 子类继承抽象类，那么一定要实现抽象类的方法否则该子类就要声明为抽象类

接口

• interface 关键字
• 继承接口用 implement
• 接口是继承类更高标准 的约束
• 接口可以多继承
• 接口不是类 不可以实例化
• 作用：
  1. 一个约束
  2. 可以定义一些方法让不同人去实现

可变参数

• 在方法声明中，在指定参数类型后面加一个省略号（…）

• 一个方法中只能指定一个可变参数，它必须是最后一个参数，任何普通参数必须在他之前声明

  public class Demo04 { public static void main(String[] args) { Demo04 demo04 = new Demo04(); demo04.printOf(1,1,2,3,4); } // 定义一个方法 public void printOf(int k，int... i){ for (int j = 0; j <4; j++) { System.out.println(i[j]); } System.out.println(k); } } // 打印出 1，2，3，4，1

类型转换

• 基本类型

byte short char int long float double

• 运算中，不同类型的数据先转换为同一个类型，然后再进行运算

int i = 10；
byte b = (byte)i; // 强制转换格式
System.out.println(b);

• 注意点：
  1. 不能对布尔值进行转换
  2. 不能将高精度的数值转换成低精度的数值
  3. 转换的时候可能存在溢出，或者精度的问题

• 自动转换

  出现在 低转高

char a = "a";
int d = a+1;
// ->   d=98

方法的定义和调用简单使用

• 简单的一个程序

/**
 * 比大小
 */
public class demo03 {
    public static void main(String[] args) {

        System.out.println(add(1,2));

    }
    public static int add(int a,int b){
        int result = 0;
        if(a>b){
            result = a;
        }else result =b;

        return result;

    }
}

• 其中方法加上了static则为类方法 在main方法中就可以直接调用

方法的重载

1. 方法的名称必须相同
2. 参数列表必须不同
3. 方法的返回类型可以相同可以不同
4. 仅仅只有返回类型不同 不可

原理：是 通过 Java 虚拟机根据 调用的方法自行对参数个数，参数类型等逐个匹配 聪儿选择对应的方法

微信小程序先导知识点

• ==什么叫做API==
  link

• app.js、app.json、app.wxss

关键的三个文件：.js后缀的是脚本文件，.json后缀的文件是配置文件，.wxss后缀的是样式表文件。微信小程序会读取这些文件，并生成小程序实例

==详解==

1. app.js是小程序的脚本代码。我们可以在这个文件中监听并处理小程序的生命周期函数、声明全局变量。调用框架提供的丰富的API，如本例的同步存储及同步读取本地数据。
2. app.json 是对整个小程序的全局配置。我们可以在这个文件中配置小程序是由哪些页面组成，配置小程序的窗口背景色，配置导航条样式，配置默认标题。注意该文件不可添加任何注释。
3. app.wxss 是整个小程序的公共样式表。我们可以在页面组件的 class 属性上直接使用 app.wxss 中声明的样式规则。

==注意==

• 在实例程序的代码中还有2个文件夹，一个是pages,一个是utils,其中utils是放通用工具类方法的一个文件夹，pages是存放所有页面的文件夹。

• 每一个小程序页面是由同路径下同名的四个不同后缀文件的组成，如：==index.js、index.wxml、index.wxss、index.json==。.js后缀的文件是脚本文件，.json后缀的文件是配置文件，.wxss后缀的是样式表文件，.wxml后缀的文件是页面结构文件。

• index.wxml 是页面的结构文件：本例中使用了、、来搭建页面结构，绑定数据和交互处理函数。

  <!--index.wxml--> <view class="container"> <view bindtap="bindViewTap" class="userinfo"> <image class="userinfo-avatar" src="{{userInfo.avatarUrl}}" background-size="cover"></image> <text class="userinfo-nickname">{{userInfo.nickName}}</text> </view> <view class="usermotto"> <text class="user-motto">{{motto}}</text> </view> </view>

• index.js 是页面的脚本文件，在这个文件中我们可以监听并处理页面的生命周期函数、获取小程序实例，声明并处理数据，响应页面交互事件等。

//index.js
//获取应用实例
var app = getApp()
Page({
  data: {
    motto: 'Hello World',
    userInfo: {}
  },
  //事件处理函数
  bindViewTap: function() {
    wx.navigateTo({
      url: '../logs/logs'
    }) },
  onLoad: function () {
    console.log('onLoad')
    var that = this
    //调用应用实例的方法获取全局数据
    app.getUserInfo(function(userInfo){
      //更新数据
      that.setData({
        userInfo:userInfo
      })
    })
  }
})

• index.wxss 是页面的样式表：
• 页面的样式表是非必要的。当有页面样式表时，页面的样式表中的样式规则会层叠覆盖 app.wxss 中的样式规则。如果不指定页面的样式表，也可以在页面的结构文件中直接使用 app.wxss 中指定的样式规则。

/**index.wxss**/
.userinfo {
  display: flex;
  flex-direction: column;
  align-items: center;
}

.userinfo-avatar {
  width: 128rpx;
  height: 128rpx;
  margin: 20rpx;
  border-radius: 50%;
}

.userinfo-nickname {
  color: #aaa;
}

.usermotto {
  margin-top: 200px;
}

• index.json 是页面的配置文件：
• 页面的配置文件是非必要的。当有页面的配置文件时，配置项在该页面会覆盖 app.json 的 window 中相同的配置项。如果没有指定的页面配置文件，则在该页面直接使用 app.json 中的默认配置。
• logs 的页面结

  <!--logs.wxml--> <view class="container log-list"> <block wx:for-items="{{logs}}" wx:for-item="log"> <text class="log-item">{{index + 1}}. {{log}}</text> </block> </view>

• ==logs 页面使用 控制标签来组织代码，在 上使用 wx:for-items 绑定 logs 数据，并将 logs 数据循环展开节点==

//logs.js
var util = require('../../utils/util.js')
Page({
  data: {
    logs: []
  },
  onLoad: function () {
    this.setData({
      logs: (wx.getStorageSync('logs') || []).map(function (log) {
        return util.formatTime(new Date(log))
      })
    })
  }
})

自增自减符号、Math类、位运算符

• 简单理解

• 一个例子

public class demo01 {
    public static void main(String[] args) {
        int a = 2;
        int b = a++;
// 这里隐藏了一个 a = a+1；
        System.out.println(a);
        System.out.println(b);
        int c = ++a;
        System.out.println(c);
/*
 * 3
 * 2
 * 4
 */
    }
}

• 幂运算 使用工具类运算
• Math类

// 2的三次方
double a = Math.pow(3,2);
// -> 8

• 位运算

  A = 0011 1100

  B = 0000 1101

  A^B = 0011 0001 // 异或 相同取0 相异取1

  ~B = 1111 0010 // 取反

• << >>

  1. << 左移 相当于 *2 >> 右移 相当于 /2

     

layout: w
title: 面向对象三大特性
date: 2021-09-17 14:57:04
tags: 面向对象
categories: java

面向对象-封装

• 高内聚低耦合

  高内聚就是类的内部数据操作细节自己来完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

• 封装（隐藏的数据）

  应禁止直接访问一个对象中的数据的实际表示，而通过操作接口来访问，称之为信息隐蔽

• 封装大多数是对于 数据来说，对于方法较少使用

• 对于私有属性 我们需要提供可以访问这个属性的方法
• get/set
• 通过get方法去获取这个属性 通set方法去给属性赋值

• 总结 ——封装好处
  1. 提高程序的安全性
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统可维护性增加了

面向对象—继承

• Java中继承只有单继承，没有多继承
• extends
• 子类继承父类
  1. 子类拥有父类的全部的方法（public）
  2. 私有（private）不可继承
• Ctrl + h Idel 弹出 继承树

super 和 this

• super的注意点：

  1. 是调用父类的构造方法，必须在构造方法的第一个
  2. super 必须只能出现在子类的方法和构造函数中
  3. super和this不能同时调用构造方法

• Vs this：

  1. 代表的对象不同：

     this 本身调用者这个对象  
     
     super ：代表父类对象的应用

  2. 前提：

     this： 没有继承也可以使用
     
      super：代表父类对象的应用

多态

• 重写
  1. 需要有继承关系，子类重写父类的方法
  2. 方法名必须相同
  3. 参数列表必须相同
  4. 修饰符：范围可以扩大： public > protected >default > private
  5. 抛出的异常 范围 可以被缩小 但不能扩大
  6. 重写 ：子类的方法和父类必要一致 方法体不同
• 为什么需要重写
  1. 父类的功能，子类不一定需要，或者不一定满足
• 对于static 方法在继承中的使用 与 （非静态）方法的区别
• 还涉及到 父类引用指向子类
• 父类引用指向子类 详解：博客文章

多态详解

• 同一个方法可以根据发送对象的的不同而采用多种不同的行为方式

• 多态存在的条件

  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象

• 注意： 多态是方法的多态，属性没有多态性

• 不可

  1. static方法 属于类 它不属于实例
  2. final 常量
  3. private 方法

instanceof 和类型转换

• instanceof （类型转换）引用类型 判断一个对象是什么类型

• // object  person student
  // object  person teacher
  Object object = new Student(); 
  System.out.println(object instanceof Student );
  // ture 
  // 主要是观看 instanceof 左右两边是否 有继承关系 
  <!--0-->

• 需要转换条件：

  • 父类引用指向子类的对象

数组

• 声明

  int[] nums;// 声明一个数组 nums = new int[10];// 创建一个数组 nums[0] = 1; nums[1] = 2;// 给数组中的元素赋值

• 简化统一 :静态初始化

  int[] nums ={1,2,3,4,5}; for (int i = 0; i <nums.length; i++) { System.out.println(nums[i]); }

• 直接将声明和初始化放在一块：动态初始化

  int[] nums = new int[10]; nums[0] = 1; nums[1] = 2;

小结①：

1. 数组也是对象，数组元素相当于成员的成员变量
2. 数组的长度是一定的

多维数组

• 多维数组可看作为是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

int[][] array ={{1,2},{2,3},{3,4},{4,5}};

for (int i=0;i<array.length;i++){
    for(int j=0;j<array[i].length;j++){
        System.out.println(array[i][j]);
    }
}

Arrays

• 工具类

• 列举几个常用的方法

int[] nums ={1,2,3,5,4};
System.out.print(Ayyays.toString(nums));//d
// [1,2,3,5,4]
Ayyays.sort(nums); // 升序排序
System.out.print(Ayyays.toString(nums));
// [1,2,3,4,5]